Fundamentos de Programación y Python
Fundamentos de Programación con Python para Principiantes
Instalación y Uso Básico de Python en Windows y Mac
Semántica y Sintaxis en Programación Python
Práctica: Te doy la bienvenida a los ejercicios interactivos
Manejo de Cadenas y Operaciones Básicas en Python
Tipos de Datos en Python: Enteros, Flotantes y Booleanos
Dominio de la función `print` en Python: usos y formatos avanzados
Operaciones matemáticas avanzadas en Python: módulo, potencia y más
Entrada de información y manejo de tipos de datos en Python
Colección y Procesamiento de Datos en Python
Manipulación de Listas en Python: Creación, Indexación y Métodos Básicos
Copiar listas en Python sin compartir memoria con slicing
Manejo de Matrices y Tuplas en Python
Matrices en Juegos y Imágenes con Python
Diccionarios en Python: Uso y Manipulación de Datos
Control de Flujo en Python
Estructuras Condicionales en Programación: Uso de If, Else y Elif
Iteración y control de flujo con bucles en Python
Iteradores y Generadores en Python: Uso Eficiente de Memoria
Listas por comprensión en Python: creación y optimización de listas
Funciones y Manejo de Excepciones en Python
Funciones y Parámetros en Python: Crea una Calculadora Básica
Funciones Lambda en Python: Uso y Aplicaciones Prácticas
Recursividad en Python: Factoriales y Serie de Fibonacci
Manejo de Excepciones y Errores en Python
Programación Orientada a Objetos en Python
Programación Orientada a Objetos en Python: Clases y Métodos Básicos
Gestión de Biblioteca con Programación Orientada a Objetos
Herencia y Polimorfismo en Programación Orientada a Objetos
Programación Orientada a Objetos: Implementación de Clases y Herencia
Polimorfismo en Programación Orientada a Objetos
Herencia y Uso de la Función super() en Python
Programación Orientada a Objetos: Atributos, Métodos y `super()` en Python
Lectura y escritura de archivos
Manipulación de Archivos TXT y CSV en Python
Manipulación de archivos CSV con Python: lectura y escritura
Manejo de Archivos JSON en Python para Aplicaciones Web y APIs
Biblioteca estándar de Python
Uso Eficiente de la Biblioteca Estándar de Python
Uso de las librerÃas OS, Math y Random en Python
Análisis de Datos de Ventas con Python y Statistics
Desarrollo del juego Batalla Naval en Python
Conceptos avanzados de Python
Programación Avanzada en Python: POO, Excepciones y Proyectos
Escritura de Código Pytónico y Buenas Prácticas en Python
Comentarios y Docstrings: Buenas Prácticas en Programación
Tiempo de vida y alcance de variables en Python
Anotaciones de Tipo en Python para Código Más Legible
Validación de Tipos y Manejo de Excepciones en Python
Estructuras de Datos Avanzadas en Python: Collection y Enumeraciones
Decoradores
Decoradores en Python: Extiende Funcionalidades de Funciones
Uso de Decoradores Anidados y con Parámetros en Python
Decoradores en Programación Orientada a Objetos en Python
Métodos y estructura de clases en Python
Uso de Métodos Mágicos en Python
Sobrecarga de Operadores en Python: Personaliza Comportamiento de Clases
Ejecutar scripts Python con `if __name__ == '__main__'`
Metaprogramación en Python: Métodos `__new__` y `__init__`
Uso de *args y **kwargs en funciones de Python
Métodos y Atributos Privados y Protegidos en Python
Uso de Property en Python: Getter, Setter y Eliminación de Atributos
Métodos estáticos y de clase en Python
Programación concurrente y asÃncrona
Concurrencia y Paralelismo en Python: Técnicas y LibrerÃas Básicas
Concurrencia y Paralelismo en Python: `threading` y `multiprocessing`
Asincronismo en Python con AsyncIO y Corrutinas
SincronÃa y Concurrencia en Python: TeorÃa y Práctica
Creación de módulos y paquetes
Módulos y Paquetes en Python: Reutilización y Organización de Código
Uso de Paquetes y Subpaquetes en Python con Visual Studio Code
Publicación de Paquetes Python en PyPI
Proyecto final
Sistema de Gestión de Reservas en Python Avanzado
Sistema de Gestión de Reservas en Python Avanzado
No tienes acceso a esta clase
¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera
Si ya tienes una cuenta,
Iteradores y Generadores en Python: Uso Eficiente de Memoria
17/63Recursos
Trabajar con iteradores y generadores en Python permite manejar grandes cantidades de datos de manera eficiente, sin necesidad de cargar todo en memoria.
¿Qué es un iterador y cómo se usa?
Un iterador en Python es un objeto que permite recorrer todos los elementos de una colección, uno a la vez, sin necesidad de usar Ãndices. Para crear un iterador, se utiliza la función iter() y para obtener el siguiente elemento, se usa la función next(). Veamos un ejemplo:
# Crear una lista
lista = [1, 2, 3, 4]
# Obtener el iterador de la lista
iterador = iter(lista)
# Usar el iterador para obtener elementos
print(next(iterador)) # Imprime: 1
print(next(iterador)) # Imprime: 2
print(next(iterador)) # Imprime: 3
print(next(iterador)) # Imprime: 4
# Intentar obtener otro elemento después de finalizar la iteración
print(next(iterador)) # Esto generará una excepción StopIteration
Los iteradores también pueden recorrer cadenas de texto:
# Crear una cadena
texto = "hola mundo"
# Obtener el iterador de la cadena
iterador_texto = iter(texto)
# Iterar a través de la cadena
for caracter in iterador_texto:
print(caracter)
¿Cómo crear un iterador con range para números impares?
La función range se puede usar para crear un iterador que recorra números impares:
# Crear un iterador para números impares hasta 10
limite = 10
iterador_impares = iter(range(1, limite + 1, 2))
# Iterar a través de los números impares
for numero in iterador_impares:
print(numero)
Para cambiar a números pares, solo se debe modificar el inicio del rango:
# Crear un iterador para números pares hasta 10
iterador_pares = iter(range(0, limite + 1, 2))
# Iterar a través de los números pares
for numero in iterador_pares:
print(numero)
¿Qué es un generador y cómo se utiliza?
Un generador es una función que produce una secuencia de valores sobre los cuales se puede iterar, usando la palabra clave yield en lugar de return. Aquà hay un ejemplo básico:
def mi_generador():
yield 1
yield 2
yield 3
# Usar el generador
for valor in mi_generador():
print(valor)
¿Cómo crear un generador para la serie de Fibonacci?
La serie de Fibonacci es una secuencia donde cada número es la suma de los dos anteriores. Podemos crear un generador para producir esta serie:
def fibonacci(limite):
a, b = 0, 1
while a < limite:
yield a
a, b = b, a + b
# Usar el generador para la serie de Fibonacci hasta 10
for numero in fibonacci(10):
print(numero)
Aportes 293
Preguntas 3
Ordenar por:
Para los que les interesa saber por que escribio 1,limit+1,2 en la linea 7 de codigo, asi funciona la syntaxis:
`# range(start, stop, step)`
start: por donde empieza
stop: donde para limit+1 = 10
step: numero de posiciones que avanza
* **Iteradores**: Necesitan definir explÃcitamente los métodos `__iter__()` y `__next__()`.
* **Generadores**: Se definen usando una función con `yield`.
Mi aporte al reto:
Los iteradores tienen la ventaja de ocupar menos memoria y de ser procesados con mayor velocidad que una estructura de datos tradicional ya que sus elementos son creados al momento de usarlos y no desde antes como las listas. Para construir un iterador sin pasar por otra estructura, es necesario el uso de clases. Por otro lado Un generador se puede interpretar como sugar syntax de los iteradores.
El curso va muy bien, pero que salto tan brusco se da con el tema de generador. Se introduce de tajo el concepto de return y función sin un contexto previo. Es un detalle a mejorar.
**Generadores** son funciones que devuelven elementos uno a uno utilizando `yield` en lugar de `return`. Cada vez que se llama, el generador "recuerda" en qué punto se quedó y continúa desde ahÃ, en lugar de empezar desde el principio. Son útiles para trabajar con grandes cantidades de datos sin cargarlos todos en memoria.
**Iteradores** son objetos que permiten recorrer una secuencia de datos (como listas o generadores) usando `next()`. Un generador es un tipo especial de iterador.
El uso de `yield` convierte una función en un generador, permitiendo devolver valores de uno en uno de forma eficiente.
Mi aporte del reto
```js
def numeros_impares(limite):
a = 1
while a < limite:
yield a
a += 2
def numeros_pares(limite):
a = 0
while a < limite:
yield a
a += 2
print("\nNumeros Impares\n")
for num in numeros_impares(20):
print(num)
print("\nNumeros pares\n")
for num in numeros_pares(20):
print(num)
```
for num in numeros\_pares(20):Â Â print(num)
Mi cabeza exploto con esta clase.
segun entiendo un generador es un bucle solo que no nos da todos los valores del bucle de inmediato, lo hace un elemento cada vez que ejecutamos el bucle para eso usamos yield que es donde queda guardados los datos de todo el bucle en espera para que lo ejecutemos de nuevo y nos de 4el siguiente dato.
y para ejecutar de nuevo el bucle lo podemos hacer dentro de una funcion y para que nos de el siguiente dato debemos usar el metodo next
y segun entendi el iterador seria la funcion con el bucle adentro y con el metodo next hacemos que se imprima el siguiente valor del generador uno por uno
Por si alguno se pregunta en donde puedo usar iter()
Aqui algunos casos de uso dentro de los labores:
* Cuando se trabaja con archivos de texto o archivos de datos que son demasiado grandes para cargarlos completamente en la memoria, `iter()` permite leer el archivo lÃnea por lÃnea o bloque por bloque
* Cuando se interactúa con APIs o bases de datos que devuelven grandes conjuntos de resultados, `iter()` permite recuperar los resultados de forma incremental, evitando la sobrecarga de la memoria.
* En combinación con librerias de programación asincrona, los iteradores permiten un manejo muy eficiente de los datos provenientes de fuentes externas.
Sigo creyendo que hay clases que explica muy bien. Pero hay cosas que no fundamenta que cosas es uno y el otro. Este tipo de cursos deberia fundamentar la diferencia entre uno y el otro y para que se servirian en un futuro. Aquà desde el min 7 me parece que no aprendo nada
Ayer busqué este curso porque querÃa ser el primero en tomarlo, comentar algo vaya, pero no lo encontré. Lo importante es que ya está disponible
Mi aporte al reto por acá: Permite seleccionar el lÃmite, si quiere los números impares o pares, y un número para iniciar la serie:
```python
def odd_even_printer(limit):
number_type = input('Escribe el print deseado(par o impar): ')
a = int(input('Seleccione un número para iniciar la serie: '))
while a < limit :
if number_type == 'par':
#Si el número de inicio es impar, lo corre al par siguiente más cercano.
if a % 2 != 0:
a += 1
yield a
a += 2
elif number_type == 'impar':
#Si el número de inicio es par, lo corre al impar siguiente más cercano
if a % 2 == 0:
a += 1
yield a
a += 2
for num in odd_even_printer(int(input('Selecciona un número limite: '))):
print(num)
```
La función `par_impar(limit)` que has definido es un generador que itera a través de un rango de números hasta el valor `limit`, identificando si cada número es par o impar. Utiliza `yield` para devolver los valores, lo que permite que la función devuelva resultados uno a uno sin cargar todos los valores en memoria.
Aquà está tu código comentado para claridad:
```python
def par_impar(limit):
for i in range(limit):
if i % 2 == 0:
yield i, "par"
else:
yield i, "impar"
for num, tipo in par_impar(10):
print(num, tipo)
```
Este código imprimirá los números del 0 al 9, indicando si cada uno es "par" o "impar". ¡Sigue practicando con generadores en Python, ya que son muy útiles para manejar grandes volúmenes de datos!
Usando generadores para numeros pares e impares, decidà pasar un parametro start que ya esta inicializado pero siempre con la opción de sobreescribir
```js
def generator_even(limit, start=0):
while start < limit:
if start % 2 == 0:
yield start
start += 1
print('even')
for ev in generator_even(100, 4):
print(ev)
def generator_odd(limit, start=0):
while start < limit:
if start % 2 != 0:
yield start
start += 1
print('odd')
for od in generator_odd(100, 4):
print(od)
```
Quise hacer el reto un poco más interactivo, por lo que añadà "input" para determinar el lÃmite de los números y si querÃa par o impar.
Aquà está el código:
`#RETO: HACER EL GENERADOR PA VER LOS NÚMEROS PARES E IMPARESextension = int(input("Escribe el número lÃmite: ")) #preguntamos el número lÃmite y la almacenamos en una variableeleccion = input("Escribe 'par' para elegir números pares: ") #Preguntamos la opción y la almacenamos en una variableprint(("Elegiste números {} hasta el {}".format(eleccion, extension))) #Informamos sobre las elecciones`
`def num_impar_par(limit, eleccion): #creamos la función  if eleccion == "par":    a = 0  # Inicia en 0 si queremos pares  else:    a = 1  # Inicia en 1 si queremos impares    # Ciclo para generar números hasta que 'a' sea igual o mayor que el lÃmite  while a < limit+1:    yield a  # Genera el número actual    a += 2  # Incrementa 'a' en 2 para obtener el siguiente número (par o impar)`
`for num in num_impar_par(extension, eleccion):Â Â print(num)`
![]()
Inputs y consola:
Espero les ayude!
Hola! Les comparto mi solución al reto:
Despues de ver, esta clase 4 veces, anotar cada expresión entendi, la formulación de los generados, muchas gracias, muy interesante!
Si te preguntas el concepto de generador:
Imagina que tienes una receta para hacer galletas. Hay dos maneras de hacerlo:
1. **Método tradicional (como una función normal)**: Haces TODAS las galletas de una vez, las pones en una bandeja y entregas la bandeja completa.
2. **Método con generador (usando** `yield`**)**: Vas haciendo y entregando las galletas UNA POR UNA, según te las pidan.
Un generador en Python es como el segundo método. En lugar de crear y devolver todos los resultados a la vez, produce un valor, se detiene, y espera hasta que le pidan el siguiente valor.
\#Crear un iterador para los numeros impares#Limitelimit = 10odd\_numbers = iter(range(1, limit + 1, 2))for number in odd\_numbers:Â Â print(number) #1 3 5 7 9
\#Crear un iterador para los numeros pares#Limitelimit = 10odd\_numbers = iter(range(0, limit + 1, 2))for number in odd\_numbers:Â Â print(number) #0 2 4 6 8 10
Mi aporte al reto:
```js
### Números pares e impares
valida_limit = True
valida_par_impar = True
limit = 0
esPar = True
def numeros_par_impar(limite, esPar):
if esPar:
for par in range(0, limite+1, 2):
yield par
else:
for impar in range(1, limite+1, 2):
yield impar
while(valida_limit):
try:
limit = int(input("Ingrese el lÃmite de la cadena de secuencia de números deseados: "))
valida_limit = False
except:
print("Debe ingresar un valor válido")
while(valida_par_impar):
par_impar = input("Ingrese si desea que la secuencia sea PAR o IMPAR. Escriba [PAR] o [IMPAR]")
if(par_impar == "PAR" or par_impar == "IMPAR"):
if(par_impar == "PAR"):
esPar = True
else:
esPar = False
valida_par_impar = False
else:
print("Debe ingresar un valor válido")
for numero in numeros_par_impar(limit,esPar):
print("Número: ", numero)
```### Números pares e impares
valida\_limit = Truevalida\_par\_impar = Truelimit = 0esPar = True
def numeros\_par\_impar(limite, esPar): if esPar: for par in range(0, limite+1, 2): yield par else: for impar in range(1, limite+1, 2): yield impar
while(valida\_limit): try: limit = int(input("Ingrese el lÃmite de la cadena de secuencia de números deseados: ")) valida\_limit = False except: print("Debe ingresar un valor válido") while(valida\_par\_impar): par\_impar = input("Ingrese si desea que la secuencia sea PAR o IMPAR. Escriba \[PAR] o \[IMPAR]") if(par\_impar == "PAR" or par\_impar == "IMPAR"): if(par\_impar == "PAR"): esPar = True else: esPar = False valida\_par\_impar = False else: print("Debe ingresar un valor válido")
for numero in numeros\_par\_impar(limit,esPar): print("Número: ", numero)
def NumPar(limite):  num = 0  while num <= limite:    yield num    num += 2
print("Numeros Pares: ")for par in NumPar(10):Â Â print(par)
def NumImpar(limite):  num = 1  while num <= limite:    yield num    num += 2
print("Numeros Impares: ")for impar in NumImpar(10):Â Â print(impar)
\#función generalizada para numeros pares e impares
def numeros(tipo,limite):  num = 0 if tipo == "par" else 1  while num <= limite:    yield num    num += 2
print("Numeros Pares: ")for n in numeros("par",10):Â Â print(n)
print("Numeros Impares: ")for n in numeros("impar",10):Â Â print(n)
Aunque el bucle `for` en Python ya permite iterar sobre cadenas y otras colecciones de manera sencilla, declarar un objeto iterador puede ser útil en situaciones donde necesitas un control más granular sobre la iteración.
Los iteradores permiten obtener el siguiente elemento bajo demanda usando `next()`, lo que es útil en escenarios de procesamiento de datos grandes, donde no quieres cargar toda la colección en memoria. Además, puedes crear iteradores personalizados que manejan lógicas de iteración especÃficas que no son posibles solo con bucles `for`.
Asà que, aunque parece redundante, los iteradores ofrecen flexibilidad y eficiencia en ciertas circunstancias.
```python
user_input = int(input("--> Give me a num: "))
#TUPLE UNPACKING IS HAPPENING
def even_odd_gen(max_n): # Say 9
counter = 1
while counter <= max_n: #9
yield (counter, "Even" if counter %2==0 else "Odd")
counter += 1
caller = even_odd_gen(user_input)
for counter_num, e_o_decision in caller:
print(f"{counter_num} - {e_o_decision}")
#Tuple unpacking
```
```js
# Numeros pares
def even_numbers(limit):
a = 0
while a < limit + 1:
yield a
a += 2
for even in even_numbers(10):
print(even)
# Numeros impares
def odd_numbers(limit):
a = 1
while a < limit + 1:
yield a
a += 2
for odd in odd_numbers(10):
print(odd)
```
def gen(limite,es\_par):
for numero in range(0 if es\_par else 1,limite+1,2):
yield numero
for numero in gen(20,par=True): #Cambiar a False si se quieren los impares
print(numero)
practica con numeros impares
limit = 20 odd\_itter = iter(range(1,limit+1,2))for num in odd\_itter:Â Â print(num)
Mi solución al reto:
```js
def paresImpares(limit):
pares = []
impares = []
for i in range(1, limit + 1):
if i % 2 == 0:
pares.append(i)
else:
impares.append(i)
yield pares, impares
for pares, impares in paresImpares(10):
print(f"Pares: {pares}")
print(f"Impares: {impares}")
```
Mezcle un poco de lo que aprendi en el reto anterior y lo agregue al ejercicio
```python
print("\n ----------------- Generador Par o Impar -------------------- \n")
def par_impar(limit, a):
while a < limit + 1:
yield a
a = a + 2
valid_letters = ['P', 'I']
while True:
print("Digite la letra P para generar los numeros pares o la letra I para los impartes:")
generator = input().upper()
if generator not in valid_letters:
print(generator + " Eleccion no valida.")
continue
if generator == "P":
for num in par_impar(11,0):
print(num)
break
if generator == "I":
for num in par_impar(11,1):
print(num)
break
```
realice cada ejercicio que esta en la practica sin usar Iter y note que daba el mismo resultado, entonces por el momento no me queda claro su porposito
```python
#Generador de números pares
def generator_for(limit):
for i in range(limit + 1):
if i % 2 == 0:
yield i
#Generador de números impares
def generator_odd(limit):
for i in range(limit +1):
if i % 2 != 0:
yield i
#Usando los generadores
limit = 10
print("Números pares")
for num in generator_for(limit):
print(num)
print("\nNúmeros impares")
for num in generator_odd(limit):
print(num)
```*#Generador de números pares*def generator\_for(*limit*):  *for* i *in* range(*limit* + 1):    *if* i % 2 == 0:      *yield* i
*#Generador de números impares*def generator\_odd(*limit*):  *for* i *in* range(*limit* +1):    *if* i % 2 != 0:      *yield* i
*#Usando los generadores*limit = 10print("Números pares")*for* num *in* generator\_for(limit):  print(num)
print("\nNúmeros impares")*for* num *in* generator\_odd(limit):  print(num)
```js
def pares(limit):
a = 0
while a < limit:
yield a
a = a + 2
for num in pares(100):
print(num)
```
Hola, les compato el uso del generador para obtener números primos
```python
def primos(limite):
primo = 2
while primo<=limite:
yield primo
if primo ==2:
p = primo+1
else: p = primo + 2
is_primo = False
while is_primo == False:
is_primo = True
iterador = iter(range(2,p))
for i in iterador:
if p%i==0:
is_primo = False
p+=1
primo = p
for num in primos(10):
print(num)
```
Mi respuesta al reto:
Este código permite recibir dos parametros, el primero si el numero es par buscar los pares hasta el limite que es el segundo parametro, si el parametro es impar realiza la busqueda respectiva para los impares
Solución al problema planteado:
SÃ, las iteraciones y generadores como `yield` son aplicables en el campo de las redes neuronales y machine learning. Permiten manejar grandes volúmenes de datos de manera eficiente. Por ejemplo, al procesar datos en lotes, los generadores pueden enviar solo un subconjunto de datos a la red neuronal en cada ciclo, optimizando el uso de memoria y mejorando la velocidad de entrenamiento. Esto es fundamental en situaciones donde los datasets son demasiado grandes para caber en memoria, como suele ocurrir en proyectos de inteligencia artificial.
Tambien podria funcionar asi:limit =16#Crear iteradorimpar\_itter = iter(range(1, limit+1, 2))par\_itter= iter(range(0, limit+2, 2))
\#Usar el iteradorfor num1 in impar\_itter:Â Â print("numero impar",num1)for num2 in par\_itter:Â Â print("numero par",num2)```js
limit =16
#Crear iterador
impar_itter = iter(range(1, limit+1, 2))
par_itter= iter(range(0, limit+2, 2))
#Usar el iterador
for num1 in impar_itter:
print("numero impar",num1)
for num2 in par_itter:
print("numero par",num2)
```
Buenas aca dejo mi aporte un poco ampliado agregando un poquito de UX con un pequeño menu numerico
```js
#Generador de numeros pares
def even_numbers(start, limit):
while start <= limit:
if start % 2 == 0:
yield start
start += 2
else:
start += 1
#Generador de numeros impares
def odd_numbers(start, limit):
while start <= limit:
if not start % 2 == 0:
yield start
start += 2
else:
start += 1
#Generador de secuencia fibonacci
def fibonacci(start, limit):
a = 0
b = 1
while a <= limit:
if a >= start:
yield a
a, b = b, a + b
#Generador de numeros general
#Mensaje de bienvenida
print("Bienvenido a su generador de grupos numericos")
#Flag para seleccion valida
invalid = True
#Verificacion de eleccion
while invalid:
x = int(input("Ingrese el generador que desea utilizar:\n1. Pares\n2. Impares\n3. Secuencia Fibonacci\n4. Todos los anteriores\n"))
#En caso de ingresar una opcion no valida se pide el reingreso
if x < 1 or x > 4:
print("*ERROR*\nNumero ingresado invalido, intentelo de nuevo.")
#En caso de ingreso valido se continua
else:
invalid = False
#Ingreso de cota inferior
a = int(input("Ingrese el numero desde el que desea comenzar: "))
#Ingreso de cota superior
b = int(input("Ingrese el ultimo valor que desea analizar: "))
#Derivacion por opcion elegida
if x == 1:
print("Los numeros pares en el rango seleccionado son:")
for par in even_numbers(a,b):
print(par)
elif x == 2:
print("Los numeros impares en el rango seleccionado son:")
for impar in odd_numbers(a,b):
print(impar)
elif x == 3:
print("Los numeros de la secuencia fibonacci contenidos dentro del rango especificado son:")
for fib in fibonacci(a,b):
print(fib)
else:
print("Los numeros pares en el rango seleccionado son:")
for par in even_numbers(a,b):
print(par)
print("Los numeros impares en el rango seleccionado son:")
for impar in odd_numbers(a,b):
print(impar)
print("Los numeros de la secuencia fibonacci contenidos dentro del rango especificado son:")
for fib in fibonacci(a,b):
print(fib)
```#Generador de numeros paresdef even\_numbers(start, limit):  while start <= limit:    if start % 2 == 0:      yield start      start += 2    else:      start += 1
\#Generador de numeros imparesdef odd\_numbers(start, limit):  while start <= limit:    if not start % 2 == 0:      yield start      start += 2    else:      start += 1#Generador de secuencia fibonaccidef fibonacci(start, limit):  a = 0  b = 1  while a <= limit:    if a >= start:      yield a    a, b = b, a + b
\#Generador de numeros general#Mensaje de bienvenidaprint("Bienvenido a su generador de grupos numericos")#Flag para seleccion validainvalid = True#Verificacion de eleccionwhile invalid:  x = int(input("Ingrese el generador que desea utilizar:\n1. Pares\n2. Impares\n3. Secuencia Fibonacci\n4. Todos los anteriores\n"))  #En caso de ingresar una opcion no valida se pide el reingreso  if x < 1 or x > 4:    print("\*ERROR\*\nNumero ingresado invalido, intentelo de nuevo.")  #En caso de ingreso valido se continua  else:    invalid = False#Ingreso de cota inferiora = int(input("Ingrese el numero desde el que desea comenzar: "))#Ingreso de cota superiorb = int(input("Ingrese el ultimo valor que desea analizar: "))#Derivacion por opcion elegidaif x == 1:  print("Los numeros pares en el rango seleccionado son:")  for par in even\_numbers(a,b):    print(par)elif x == 2:  print("Los numeros impares en el rango seleccionado son:")  for impar in odd\_numbers(a,b):    print(impar)elif x == 3:  print("Los numeros de la secuencia fibonacci contenidos dentro del rango especificado son:")  for fib in fibonacci(a,b):    print(fib)else:  print("Los numeros pares en el rango seleccionado son:")  for par in even\_numbers(a,b):    print(par)  print("Los numeros impares en el rango seleccionado son:")  for impar in odd\_numbers(a,b):    print(impar)  print("Los numeros de la secuencia fibonacci contenidos dentro del rango especificado son:")  for fib in fibonacci(a,b):    print(fib)
\# *Numero pares e impares*
def pares(limite):  a = 2  while a < limite:    yield a    a += 2
for num in pares(100):Â Â print(num)
def impares(limite):  a = 1  while a < limite:    yield a    a += 2
for num in impares(100):Â Â print(num)
limit = 10
\#Crear numeros impares odd\_itter = iter(range(1, limit + 1,2)) #crear numeros pares odd\_itter = iter(range(0, limit + 1,2)) #Usar el iterador for num in odd\_itter:
print(num)
```js
#generador de números pares
def pares(limite):
i=1
while i<= limite:
if i%2==0:
yield i
i+=1
#generador de números impares
def impares(limite):
i=1
while i<= limite:
if i%2!=0:
yield i
i+=1
# Imprimir los genradores
#Pares
print("números pares: ")
for numero in pares(10):
print(numero)
#Impares
print("números impares: ")
for numero in impares(10):
print(numero)
```
Mi solución al reto:
\#impares#0 2 4 6 8 10 12 14....def impares(limit):  a = 0  while a < limit:      a = a + 1         if a % 2 != 0:      yield a         for num in impares(20):  print(num)
\#pares#0 2 4 6 8 10 12 14....def pares(limit):  a = 1  while a <= limit:    a = a + 1    if a %2 == 0:      yield a     for num in pares(10):  print(num)
Buen dÃa envÃo mi aporte del reto:
```python
print("Numeros pares hasta el 20")
limite = 20
Iter_par = iter(range(0,limite+1,2))
for num in Iter_par:
print(num)
print("Numeros impares hasta el 20")
iter_impar = iter(range(1,limite+1,2))
for num in iter_impar:
print(num)
```
def Num\_pares (inicio,limite):Â
if inicio % 2 == 0:Â Â Â Â
a= inicio Â
else:Â Â Â Â
a=inicio+1Â Â
while(a<=limite):Â Â Â
 yield a   Â
a=a+2
for numeros\_pares in Num\_pares(-5,25):Â
 print(numeros\_pares)
Creo necesario que mencionar que se usa la palabra yield en lugar de return para convertir la funcion en un generador.
```js
"""
Programa que demuestra el uso de generadores en Python
"""
def impar(limit):
"""
funcion generador que devuelve los numeros impares hasta un limite
"""
i = 0
while i < limit:
if i % 2 != 0:
yield i
i += 1
def par(limit):
"""
funcion generador que devuelve los numeros pares hasta un limite
"""
i = 0
while i < limit:
if i % 2 == 0:
yield i
i += 1
print("Par 0-10")
for i in par(10):
print(i)
print()
print("Impar 0-10")
for i in impar(10):
print(i)
```
Mi aporte, pero todavÃa me confund0 con el "yield"
\#pares#0 2 4 6 8 10 12 14 16 18 20 22 24 26 28 30def pares(limit): for i in range(0, limit+1, 2): yield i
for value in pares(30): print(value)
![]()
Números pares con generadores
1. aqui mi codigo para el reto
2. def generator\_impares(limit):  a = 1  while a < limit:      yield a      a +=2for num in generator\_impares(100):   print(num)
def generator\_pares(limit):  a = 2  while a < limit:      yield a      a +=2for num in generator\_pares(100):   print(num)
```python
print("=================Numeros pares=================")
def even_par(limite):
a = 0
while a < limite:
if a%2 == 0:
yield a
a += 1
for x in even_par(12):
print(x)
print("=================Numeros impares=================")
def even_impar(limite):
a = 0
while a < limite:
if a%2 != 0:
yield a
a += 1
for x in even_impar(12):
print(x)
```
Mi aporte del reto
listo
```python
def impar (limit):
a=1
while a<limit:
yield a
a =a+2
for num in impar (100):
print (num)
```def impar (limit):  a=1  while a\<limit:    yield a    a =a+2for num in impar (100):  print (num)
Espero ayude generador de numeros pares e impares con input#Generador de numeros pares e impares*def* par(*limit*):  numpar=0  while numpar<*limit*:    yield numpar    numpar=numpar+2
*def* impar(*limit*):  numimpar=1  while numimpar<*limit*+1:    yield numimpar    numimpar=numimpar+2
for i in par(<u>int</u>(input("Ingrese el limite de numeros pares: "))):Â Â print(i)
for i in impar(<u>int</u>(input("Ingrese el limite de numeros impares: "))):Â Â print(i)```js
#Generador de numeros pares e impares
def par(limit):
numpar=0
while numpar<limit:
yield numpar
numpar=numpar+2
def impar(limit):
numimpar=1
while numimpar<limit+1:
yield numimpar
numimpar=numimpar+2
for i in par(int(input("Ingrese el limite de numeros pares: "))):
print(i)
for i in impar(int(input("Ingrese el limite de numeros impares: "))):
print(i)
```
mi solución 
Mi Aporte:
\#crear un iterador para numeros impares
limit = 10
odd\_iterador = iter(range(1, limit + 1, 2))
for num in odd\_iterador:
print(num)
\#crear un iterador para numeros pares
limit = 10
odd\_iterador = iter(range(0, limit + 1, 2))
for num in odd\_iterador:
print(num)
```js
def numeros(limite):
num=1
par=["Pares"]
impar=["Impares"]
while num < limite:
if num%2==0:
par.append(num)
else:
impar.append(num)
num += 1
yield par
yield impar
for numero in numeros(10):
print(numero)
```def numeros(limite):  num=1  par=\["Pares"]  impar=\["Impares"]  while num < limite:      if num%2==0:        par.append(num)            else:        impar.append(num)          num += 1    yield par  yield impar for numero in numeros(10):  print(numero)
![]()# Imparesdef impares ():Â Â for num in range (1,100):Â Â Â Â if num % 2 != 0:Â Â Â Â Â Â yield numfor inpar in impares():Â Â print(inpar)```js
# pares
def pares():
for num in range (1,100):
if num % 2== 0:
yield num
for par in pares():
print(par)
# Impares
def impares ():
for num in range (1,100):
if num % 2 != 0:
yield num
for inpar in impares():
print(inpar)
```aca dejo mi aporte ese es el codgio para pares e impares utilizando generadores
```python
limite_inferior, limite_superior = int(input("Digite el limite inferior: ")),int(input("Digite el limite superior: "))
def par(a, limite):
while(a <= limite):
if a % 2 !=0:
a += 1
yield a
a = a + 2
print("\nPares a partir de",limite_inferior,"hasta",limite_superior)
for i in par(limite_inferior,limite_superior):
print(i)
print("---------------------------------------")
print("\nImpares a partir de",limite_inferior,"hasta",limite_superior)
def impar(a, limite):
while(a <= limite):
if a % 2 == 0:
a +=1
yield a
a = a + 2
for i in impar(limite_inferior,limite_superior):
print(i)
```Esta es mi solución a la tarea, estoy recién empezando en Python asà que es probable que este código no sea muy eficiente. Acepto cualquier opinión :D
El mÃo lo he hecho asÃ, acepto comentarios:
```js
def even_odds_generator():
for i in range(0,21,2):
yield i, i+1
for y, x in even_odds_generator():
print(f"par = {y}, impar = {x}")
```Resultado:
par = 0, impar = 1
par = 2, impar = 3
par = 4, impar = 5
par = 6, impar = 7
par = 8, impar = 9
par = 10, impar = 11
par = 12, impar = 13
par = 14, impar = 15
par = 16, impar = 17
par = 18, impar = 19
par = 20, impar = 21
Acepto feedback :)
Es mi primera vez programando y he estado practicando ejercicios con IA.
La palabra reservada `yield` en Python se utiliza dentro de una función para convertirla en un generador. A diferencia de una función tradicional que retorna un único valor y termina su ejecución, un generador puede devolver múltiples valores a través de iteraciones. Cada vez que se llama a `next()` en el generador, la ejecución de la función se reanuda desde la última instrucción `yield`, permitiendo generar secuencias de valores uno a uno sin almacenar todos en memoria simultáneamente. Esto es especialmente útil para trabajar con grandes conjuntos de datos de manera eficiente.
La explicacion es que la funcion range incluye el limite inferior pero no el superior.
Al hacer
limit+1 = 11
El 11 queda excluido
range(1,11)
```js
#pares
def pares(limit):
a=0
while a<limit:
if a%2 ==0:
yield a
a+= 1
for p in pares(10):
print(p)
print("\n")
#impares
def impares(limit):
a=0
while a<limit:
if not a%2 ==0:
yield a
a+= 1
for im in impares(10):
print(im)
```#paresdef pares(limit):  a=0  while a\<limit:    if a%2 ==0:      yield a    a+= 1
for p in pares(10):Â Â print(p)
print("\n")#imparesdef impares(limit):  a=0  while a\<limit:    if not a%2 ==0:      yield a    a+= 1
for im in impares(10):Â Â print(im)
```python
pares =[]
impares =[]
def mi_generadorpares(limit):
a, b, = 1, 1
while a<=limit:
if a%2 == 0:
yield a
a = a+b
def mi_generadorimpares(limit):
a, b, = 0, 1
while a<= limit:
if a%2==1:
yield a
a=a+b
for valor in mi_generadorpares(10):
pares.append(valor)
for valor in mi_generadorimpares(10):
impares.append(valor)
print("impares:", impares)
print("pares:", pares)
```pares =\[]impares =\[]def mi\_generadorpares(limit):  a, b, = 1, 1  while a<=limit:    if a%2 == 0:      yield a    a = a+b
def mi\_generadorimpares(limit):Â Â a, b, = 0, 1Â Â while a<= limit:Â Â Â Â if a%2==1:
      yield a    a=a+b
for valor in mi\_generadorpares(10):Â Â pares.append(valor)Â Â for valor in mi\_generadorimpares(10):Â Â impares.append(valor)
print("impares:", impares)print("pares:", pares)
Mi aporte al reto:
```python
#Generador números Pares
def pares(limit):
a = 0
while (a % 2 ==0 and a <=limit):
yield a
a+=2
for num in pares(10):
print(num)
#Generador números Impares
def impares(limit):
a = 1
while (a < limit):
yield a
a +=2
print("-------------------------")
for num in impares(10):
print(num)
```#Generador números Paresdef pares(limit):  a = 0  while (a % 2 ==0 and a <=limit):    yield a    a+=2
for num in pares(10):Â Â print(num) Â
\#Generador números Imparesdef impares(limit):  a = 1  while (a < limit):    yield a    a +=2    print("-------------------------")for num in impares(10):  print(num) Â
`# Ejercicio: generadores para números pares e impares`
`# Pares`
`def`` even_number_generator(``limit``):Â Â for n in ``range``(0,``limit``+1,2):Â Â Â Â yield n`
`# Impares`
`def`` odd_number_generator(``limit``):Â Â Â for n in ``range``(1,``limit``+1,2):Â Â Â Â yield n`
`for number in even_number_generator(21):Â Â print(number)`
`for number in odd_number_generator(37):Â Â print(number)Â Â `
```js
pares =[]
impares =[]
def mi_generadorpares(limit):
a, b, = 1, 1
while a<=limit:
if a%2 == 0:
yield a
a = a+b
def mi_generadorimpares(limit):
a, b, = 0, 1
while a<= limit:
if a%2==1:
yield a
a=a+b
for valor in mi_generadorpares(10):
pares.append(valor)
for valor in mi_generadorimpares(10):
impares.append(valor)
print("impares:", impares)
print("pares:", pares)
```pares =\[]impares =\[]def mi\_generadorpares(limit):  a, b, = 1, 1  while a<=limit:    if a%2 == 0:      yield a    a = a+b
def mi\_generadorimpares(limit):Â Â a, b, = 0, 1Â Â while a<= limit:Â Â Â Â if a%2==1:
      yield a    a=a+b
for valor in mi\_generadorpares(10):Â Â pares.append(valor)Â Â for valor in mi\_generadorimpares(10):Â Â impares.append(valor)
print("impares:", impares)print("pares:", pares)```python
```
Mi aporte:
def numeros\_impares(limite):  a = 0  while a < limite:    yield a    a += 2
def numeros\_pares(limite):  a = 0  while a < limite:    yield a    a += 2    Â
print("\nNumeros Impares\n")
for num in numeros\_impares(20):Â Â print(num)
print("\nNumeros pares\n")
for num in numeros\_pares(20):Â Â print(num)
```js
#Clase 18 generadores e iteradores
#Ejercicio 1
print("Ejercicio 1 - Iteradores:")
new_list = [x for x in range(1,10)]
#Obteniendo el iterador
my_iter = iter(new_list)
#Imprimiendo el iterador
print(next(my_iter))
print(next(my_iter))
print(next(my_iter))
print(next(my_iter))
print(next(my_iter))
print(next(my_iter))
print(next(my_iter))
print(next(my_iter))
print(next(my_iter))
#Ejercicio 2
print("")
print("Ejercicio 2 - Iterador en cadenas:")
#Cadena
cadena = "Hola"
iterador = iter(cadena)
#Imprimiendo el iterador
for i in iterador:
print(i)
#Ejercicio 3
print("")
print("Ejercicio 3 - Iterador para numero impares:")
#LÃmite
limite = 10
#Crear iterador
add_itter = iter(range(1,limite + 1,2))
#Imprimir iterador
for i in add_itter:
print(i)
#Ejercicio 4
print("")
print("Ejercicio 4 - Iterador para numero pares:")
#LÃmite
limite = 10
#Crear iterador
add_itter = iter(range(0,limite + 1,2))
#Imprimir iterador
for i in add_itter:
print(i)
#Ejercicio 5
print("")
print("Ejercicio 5 - Generador:")
def generador():
yield 1
yield 2
yield 3
#Obteniendo el generador
for value in generador():
print(value)
#Ejercicio 6
print("")
print("Ejercicio 6 - Generador para serie de fibonacci:")
def fibonacci(limite):
a, b = 0, 1
while a < limite:
yield a
a, b = b, a+b
for i in fibonacci(20):
print(i)
```#Clase 18 generadores e iteradores
\#Ejercicio 1print("Ejercicio 1 - Iteradores:")
new\_list = \[x for x in range(1,10)]
\#Obteniendo el iteradormy\_iter = iter(new\_list)
\#Imprimiendo el iteradorprint(next(my\_iter))print(next(my\_iter))print(next(my\_iter))print(next(my\_iter))print(next(my\_iter))print(next(my\_iter))print(next(my\_iter))print(next(my\_iter))print(next(my\_iter))
\#Ejercicio 2print("")print("Ejercicio 2 - Iterador en cadenas:")
\#Cadenacadena = "Hola"iterador = iter(cadena)
\#Imprimiendo el iteradorfor i in iterador:Â Â print(i)Â Â #Ejercicio 3print("")print("Ejercicio 3 - Iterador para numero impares:")
\#LÃmitelimite = 10
\#Crear iterador add\_itter = iter(range(1,limite + 1,2))
\#Imprimir iteradorfor i in add\_itter:Â Â print(i)Â Â #Ejercicio 4print("")print("Ejercicio 4 - Iterador para numero pares:")
\#LÃmitelimite = 10
\#Crear iterador add\_itter = iter(range(0,limite + 1,2))
\#Imprimir iteradorfor i in add\_itter:Â Â print(i)Â Â Â Â #Ejercicio 5print("")print("Ejercicio 5 - Generador:")def generador():Â Â yield 1Â Â yield 2Â Â yield 3
\#Obteniendo el generadorfor value in generador():Â Â print(value)
\#Ejercicio 6print("")print("Ejercicio 6 - Generador para serie de fibonacci:")def fibonacci(limite):  a, b = 0, 1  while a < limite:    yield a    a, b = b, a+b
for i in fibonacci(20):Â Â print(i)
Mi tarea, espero este a la altura de lo que es el curso :)
Ah caray, apenas vamos a ver funciones y ya nos sueltan una en un ejercicio.
Es es mi aporte al reto:
```python
def get_even_and_odd(numbers=list()):
find_even = [f"This number {num} is: Even" for num in numbers if num % 2 == 0]
find_odd = [f"This number {num} is: Odd" for num in numbers if num % 2 != 0]
print("--------- Even Group ---------")
for is_even in find_even:
print(is_even)
print("------------------------------")
print("--------- Odd group ----------")
for is_odd in find_odd:
print(is_odd)
print("------------------------------")
numbers = list(range(1, 20))
result = get_even_and_odd(numbers)
```Resultado:
```txt
--------- Even Group ---------
This number 2 is: Even
This number 4 is: Even
This number 6 is: Even
This number 8 is: Even
This number 10 is: Even
This number 12 is: Even
This number 14 is: Even
This number 16 is: Even
This number 18 is: Even
------------------------------
--------- Odd group ----------
This number 1 is: Odd
This number 3 is: Odd
This number 5 is: Odd
This number 7 is: Odd
This number 9 is: Odd
This number 11 is: Odd
This number 13 is: Odd
This number 15 is: Odd
This number 17 is: Odd
This number 19 is: Odd
------------------------------
```
Mi solución al ejercicio
Mi aporte del reto
La parte de Generador es extraña que este aquà sin antes dar Funciones, nadie va a saber que es un "return" asà que costara mas trabajo comprender.
```js
#EJERCICIO: VER NUMEROS PARES E IMPARES
limit = (int(input("Ingrese el valor lÃmite: ")))
def numbers (limit):
a = int(input("Defina el valor inicial: "))
while a < limit:
if a%2 ==0:
yield a
a = a+2
else :
yield a
a = a+2
for num in numbers(limit):
print(num)
```Dejo mi aporte compañeros. Se agradecen comentarios
Hola Acá comparto mi generador de Pares e Impares
dejo mi aporte a la clase, aca esta el reto de los numeros pares e impares
aquà dejo mi aporte
`yield` y `return` son dos palabras clave en Python que se usan en funciones, pero tienen propósitos diferentes:
- **return** finaliza la función y devuelve un valor al llamador. Una vez que se ejecuta, la función no puede continuar.
- **yield** convierte una función en un generador. En lugar de finalizar la función, `yield` pausa su ejecución, guardando el estado actual. La próxima vez que se llame al generador, continuará desde donde se quedó, lo que permite iterar sobre una secuencia de valores sin almacenar todo en memoria.
Utilizar `yield` es útil para manejar grandes conjuntos de datos de manera eficiente.
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?