Fundamentos de Programación y Python
¿Por qué aprender Python?
Introducción a Python
Conceptos Básicos de Programación
Práctica: Te doy la bienvenida a los ejercicios interactivos
Manipulación de Cadenas de Texto en Python
Enteros, Flotantes y Booleanos
Todo lo que Debes Saber sobre print en Python
Operaciones Matemáticas en Python
Operaciones de Entrada/Salida en Consola
Colección y Procesamiento de Datos en Python
Listas
Método slice
Listas de más dimensiones y Tuplas
Aplicación de Matrices
Diccionarios
Comprehension Lists en Python (CLASE NUEVA)
Control de Flujo en Python
Estructuras condicionales
Bucles y Control de Iteraciones
Generadores e Iteradores
Funciones y Manejo de Excepciones en Python
Uso de Funciones en Python
Funciones Lambda y Programación Funcional en Python
¿Cómo realizar una función recursiva en Python?
Manejo de Excepciones y Uso de Pass (CLASE NUEVA)
Programación Orientada a Objetos en Python
Fundamentos de Programación Orientada a Objetos en Python
Ejercicio Biblioteca con POO
Herencia en POO con Python
Objetos heredados
Los 4 pilares de la programacion orientada a objetos
Uso de super() en Python (CLASE NUEVA)
Superando los Fundamentos de Programación Orientada a Objetos en Python
Lectura y escritura de archivos
Manejo de Archivos .TXT (CLASE NUEVA)
Manejo de Archivos CSV (CLASE NUEVA)
Manejo de Archivos JSON (CLASE NUEVA)
Biblioteca estándar de Python
Biblioteca estándar en Python (CLASE NUEVA)
Librería Os, Math y Random (CLASE NUEVA)
Librería Statistics y Análisis Estadístico (CLASE NUEVA)
Proyecto final: Guerra naval
Conceptos avanzados de Python
Recapitulación de lo aprendido hasta ahora
Escribir código Pythonico y profesional
Comentarios y Docstrings en Python
Scope y closures: variables locales y globales
Anotaciones de tipo
Validación de tipos en métodos
Librería Collections y Enumeraciones
Decoradores
Decoradores en Python
Decoradores anidados y con parámetros
Uso de Decoradores en clases y métodos
Métodos y estructura de clases en Python
Métodos mágicos
Sobrecarga de operadores
Implementación de `if __name__ == "__main__":`
Metaprogramación en Python
Uso de *args y **kwargs
Métodos privados y protegidos
Gestión avanzada de propiedades
Métodos estáticos y de clase avanzados
Programación concurrente y asíncrona
Introducción a la concurrencia y paralelismo
Threading y multiprocessing en Python
Asincronismo con asyncio
Asincronismo y concurrencia
Creación de módulos y paquetes
Creación de módulos en Python
Gestión de paquetes
Publicación de paquetes en PyPI
Proyecto final
Implementación de un sistema completo
Implementación de un Sistema Completo
No tienes acceso a esta clase
¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera
Si ya tienes una cuenta,
No se trata de lo que quieres comprar, sino de quién quieres ser. Aprovecha el precio especial.
Antes: $249
$209
Paga en 4 cuotas sin intereses
Termina en:
14 Días
13 Hrs
31 Min
43 Seg
Generadores e Iteradores
18/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 178
Preguntas 1
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.
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
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
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 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)
```
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
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!
Generadores e iteradores:
La palabra clave yield en Python se utiliza dentro de una función para convertirla en un generador. Cuando se llama a una función con yield, en lugar de ejecutar y devolver un valor final, esta "pausa" su ejecución y guarda su estado, devolviendo un valor al llamador. Esto permite que la ejecución se reanude más tarde desde donde se detuvo.
a = 1
b = 2
Es lo mismo que:
a, b = 1, 2
Solo que en una sola línea
yo hice de esta ,manera los números pares e impares no es algo pulido pero sirve
Generadores de Impares y Pares partiendo del generador de la serie Fibonacci.
Esto de los generadores me ha costado un poco, pero después de leer un poco más y practicar, obtuve una posible solución al reto:
```python
def evenOdd(limit):
a = 0
while a < limit:
a += 1
if a % 2 == 0:
yield a , 'even'
else:
yield a ,'odd'
for num in evenOdd(10):
print(num)
```
```js
def numPar(limit):
x=0
while(x<limit):
yield x
x+=2
for i in numPar(21):
print(i)
```def numPar(limit): x=0 while(x\<limit): yield x x+=2
for i in numPar(21): print(i)
```python
# Ejemplo de generadores en Python
# Definimos una función generadora
def generador(n, limit):
while n <= limit:
yield n
n += 2
# numeros impares
for numero in generador(1, 10):
print(numero)
# nmeros pares
for numero in generador(2, 10):
print(numero)
```# Ejemplo de generadores en Python
\# Definimos una función generadoradef generador(n, limit): while n <= limit: yield n n += 2
\# numeros imparesfor numero in generador(1, 10): print(numero)
\# nmeros paresfor numero in generador(2, 10): print(numero)
lazy evaluation o evaluacion perezosa es un concepto de python, se refiere a que una exprecion no es ejecutada hasta que su ejecucion o el valur resultante de esta sea necesaria, disminuyendo el despilfarro de recursos, asi funcionan los generadoares, por lo que me hace pensar si vas a usar recursividad ( horrible en terminos de eficiencia) tal vez sea buena idea conbinarla con un generador (lazy evaluation).
Este es un ejercicio de programación que te permite practicar la comprensión de listas, el formato de cadenas, los condicionales y los bucles:
Ejercicio: Informe de calificaciones del estudiante
Cree un programa que procese una lista de los nombres de los estudiantes y sus puntajes correspondientes en múltiples materias. El programa debe calcular el puntaje promedio de cada estudiante, determinar su calificación y generar un informe formateado.
Instrucciones:
1\.
Datos de entrada:
•
Crea una lista de diccionarios, donde cada diccionario representa a un estudiante y contiene su nombre y puntuaciones en diferentes materias.
2\.
Calcular las puntuaciones medias:
•
Utilice un bucle para recorrer en iteración la lista de alumnos y calcular su puntuación media.
3\.
Determinar las calificaciones:
•
Utilice los condicionales para asignar una calificación en función de la puntuación media:
◦
A para la puntuación media de 90 o más.
◦
B para la puntuación media entre 80 y 89.
◦
C para la puntuación media entre 70 y 79.
◦
D para la puntuación media entre 60 y 69.
◦
F para la puntuación media inferior a 60.
4\.
Generar un informe:
•
Usar formato de cadena
def pares(limit): a = 0 while a\<limit: yield a a = a+2
def impares(limit): a = 1 while a\<limit: yield a a = a+2
for value in pares(10): print(value)
for value in impares(10): print(value)
\#Impardef generador(limite): i=1 while i <= limite: i +=2 yield ifor x in generador(10): print(x)
\#pardef generador(limite): i=0 while i <= limite: i +=2 yield ifor x in generador(10): print(x)
Mi aporte:
En python los generadores e iteradores son una herramienta poderosa al momento de trabajar con colecciones de manera eficiente, podemos trabajar con grandes cantidades de información sin almacenar todo a la misma vez en memoria
ITER: Iteran cada uno de los elementos sin utilizar indices.
Generador: Función que produce una secuencia de números en los cuales podemos iterar ya no utilizamos la palabra return para devolver un valor, ahora utilizamos yield.
```js
#numeros impares con yield
def fibonacci(limit):
x = 0
while x < limit:
yield x + 1
x +=2
for num in fibonacci(10):
print(num) # 1 3 5 7 9
```#numeros impares con yield def fibonacci(limit): x = 0 while x < limit: yield x + 1 x +=2 for num in fibonacci(10): print(num) # 1 3 5 7 9
Estuve viendo varios aportes de compañeros y me parecen unos muy ganadores, yo no sé si soy muy simplista o qué, pero esta es mi solución al reto jeje:
```js
#Crear generadores de números pares
iterador = iter(range(2,100+1,2))
for par in iterador:
print(par)
#Crear generadores de números impares
iterador = iter(range(1,100+2,2))
for impar in iterador:
print(impar)
```#Crear generadores de números pares
iterador = iter(range(2,100+1,2))
for par in iterador: print(par)
\#Crear generadores de números impares
iterador = iter(range(1,100+2,2))
for impar in iterador: print(impar)
limit = 10
\#Crear iteradorodd\_
itter = iter(range(0,limit+1,2))
\#Usar el iterador
for num in odd\_itter:
print(num)
segun al docente la saliada es comoenzando con 2,pero a mi me sale comenzando con cero (0),no entendí!
```python
def even_odd_generator(limit, isEven):
a = 0 if isEven else 1
while a<limit:
yield a
a += 2
for x in even_odd_generator(10, True):
print(x)
for x in even_odd_generator(10, False):
print(x)
```Dejo mi aporte por acá!
En el generador de Fibonacci, el primer número impreso (1) corresponde al valor de la variable `a` antes de la reasignación. El código comienza con `a` = 0 y `b` = 1. Al ejecutar `yield a`, se imprime el valor de `a` antes de actualizarlo. Sin embargo, el primer `yield` ocurre antes de la reasignación, por lo que se devuelve 0 primero. La confusión puede surgir si se espera que `a` se imprima antes de ser utilizado. La solución es ajustar el orden de la lógica si se desea que el primer número sea 0.
Revisar el flujo de la lógica en el generador puede ayudar a aclarar esto.
Sí, en Python se pueden crear interfaces gráficas utilizando bibliotecas como Tkinter, PyQt o Kivy. Tkinter es la opción más común y viene incluida con Python, permitiendo crear aplicaciones de escritorio de manera sencilla. PyQt ofrece más funcionalidades y es ideal para aplicaciones más complejas, mientras que Kivy es útil para aplicaciones móviles y multitáctiles. Cada una tiene sus ventajas, así que la elección depende de tus necesidades específicas en el desarrollo.
`def impares(limit):`
`for i in range(1, limit + 1, 2):`
`yield i`
`def pares(limit):`
`for i in range(0, limit + 1, 2):`
`yield i`
Los generadores y los iteradores en Python son herramientas para manejar colecciones de datos de manera eficiente.
- **Iteradores** permiten recorrer elementos de una colección (como listas) sin necesidad de índices, usando la función `next()` para obtener el siguiente elemento. Esto es útil para trabajar con grandes conjuntos de datos sin cargar todo en memoria.
- **Generadores** son funciones que utilizan `yield` para devolver valores uno a uno, en vez de retornar todos de una vez. Esto permite crear secuencias de números o colecciones dinámicamente, como en la serie de Fibonacci, optimizando el uso de memoria.
Ambos son esenciales para gestionar flujos de datos en Python.
AQUI ESTA MI DESAFIO SON DOS UNA DONDE EL LIMTE YA ESTA ESTABLECIDO Y LA SEGUNDA DONDE EL USUARIO INGRESA EL LIMITE 😁👍😶🌫️☠️```python
print ("\n")
print("ITERAR CON NUMEROS PARES E IMPARES")
# RANGE
#CREAR ITERADOR PARA NUMEROS IMPARES
# LIMITE
limit = 25
# LA FUNCION RANGE ACEPTA 3 VALORES
# EL INICION DE LA ITERACION EN ESTA CASO ES 1
# EL LIMITE DE LA ITERACION EN ESTE CASO ES LA VARIABLE LIMIT+1
# Y DE CUANTO EN CUANTO VA A IR ITERANDO EN ESTE CASO 2
#CREAR ITERADOR
impares = iter(range(1,limit+1,2))
pares = iter(range(0,limit+1,2))
# USAR ITERADOR
print("NUMEROS IMPARES")
for num in impares:
print(num)
print("\n")
print("NUMEROS PARES")
for num2 in pares:
print(num2)
print ("\n")
print("ITERAR CON NUMEROS PARES E IMPARES CON DATOS DE TECLADO")
# RANGE
#CREAR ITERADOR PARA NUMEROS IMPARES
# LIMITE
limite_teclado = int(input ("INGRESE EL LIMITE: "))
limit_tec = limite_teclado
# LA FUNCION RANGE ACEPTA 3 VALORES
# EL INICION DE LA ITERACION EN ESTA CASO ES 1
# EL LIMITE DE LA ITERACION EN ESTE CASO ES LA VARIABLE LIMIT+1
# Y DE CUANTO EN CUANTO VA A IR ITERANDO EN ESTE CASO 2
#CREAR ITERADOR
impares_tec = iter(range(1,limit_tec+1,2))
pares_tec = iter(range(0,limit_tec+1,2))
# USAR ITERADOR
print("NUMEROS IMPARES")
for num_tec in impares_tec:
print(num_tec)
print("\n")
print("NUMEROS PARES")
for num_tec2 in pares_tec:
print(num_tec2)
```
```js
def my_generator():
yield 1
yield 2
yield 3
for value in my_generator():
print(value)
print('IMPRIMIR IMPARES HASTA EL 20')
limite=20
impares=iter(range(1,limite+1,2))
for i in impares:
print(i)
# También vale
print('IMPRIMIR IMPARES HASTA EL 20')
limite=20
impares=iter(range(1,limite+1,2))
for i in impares:
print(i)
```def my\_generator(): yield 1 yield 2 yield 3
for value in my\_generator(): print(value)
print('IMPRIMIR IMPARES HASTA EL 20')limite=20impares=iter(range(1,limite+1,2))
for i in impares: print(i)
Mi aporte al reto:
```js
#Generador para ver los números pares e impares
def fun_par_impar(x,limit):
if x=="par":
a=list(range(0,limit,2))
yield a
elif x=="impar":
a=list(range(1,limit,2))
yield a
for num in fun_par_impar("par",10):
print(num)
for num in fun_par_impar("impar",10):
print(num)
```#Generador para ver los números pares e imparesdef fun\_par\_impar(x,limit): if x=="par": a=list(range(0,limit,2)) yield a elif x=="impar": a=list(range(1,limit,2)) yield a for num in fun\_par\_impar("par",10): print(num)
for num in fun\_par\_impar("impar",10): print(num)
Tu código es correcto para crear iteradores de números impares y pares. Aquí está el desglose:
1. **Iterador de números impares**:
```python
limit = 10
num_par = iter(range(1, limit + 1, 2))
for num in num_par:
print(num)
```
Este código imprime los números impares del 1 al 9.
2. **Iterador de números pares**:
```python
limit = 10
num_par = iter(range(0, limit + 1, 2))
for num in num_par:
print(num)
```
Este imprime los números pares del 0 al 10.
Ambos son ejemplos claros de cómo usar `iter` y `range` para crear iteradores efectivos en Python.
Es comprensible que desees ver aplicaciones prácticas de la teoría. En el curso de Python, se incorporan ejercicios interactivos y proyectos prácticos a medida que avanzas. Estos te ayudarán a aplicar lo aprendido en situaciones reales. ¡Sigue adelante y aprovecha al máximo el curso!
Un iterador en Python es un objeto que permite recorrer una colección, como listas o cadenas, sin necesidad de usar índices. Se obtiene mediante la función `iter()` y se utiliza la función `next()` para acceder a los elementos uno por uno, hasta que no haya más elementos disponibles.
```js
#Tarea: hacer un generador de números pares e impares
#Pares
limite = 10
par_iter = iter (range(0,limite+1,2))
for num in par_iter:
print(num)
#Impares
limite = 10
par_iter = iter (range(1,limite+1,2))
for num in par_iter:
print(num)
```#Tarea: hacer un generador de números pares e impares
\#Pares
limite = 10par\_iter = iter (range(0,limite+1,2))for num in par\_iter: print(num)
\#Impares
limite = 10par\_iter = iter (range(1,limite+1,2))for num in par\_iter: print(num)
def generador\_pares(n):
return \[i for i in range(2, n + 1, 2)]
def generador\_impares(n):
return \[i for i in range(1, n + 1, 2)]
\# Generador de números pares
pares = generador\_pares(100) # Genera números pares hasta 100
print("Números pares:")
for par in pares:
print(par)
\# Generador de números impares
impares = generador\_impares(100) # Genera números impares hasta 100
print("Números impares:")
for impar in impares:
print(impar)
a mi no me esta resultado el codigo de Fibonacci, me da bucle infinito, y lo he escrito tal como en la clase. Necesito ayuda!
```js
#numeros pares
def num_pairs(limit):
a = 0
while a < limit:
a = a + 1
if a % 2== 0:
yield a
for num in num_pairs(10):
print(num)
#numeros inpares
def num_2(limit):
a = 0
while a < limit:
a = a + 1
if a % 2!= 0:
yield a
for num in num_2(10):
print(num)
```#numeros paresdef num\_pairs(limit): a = 0 while a < limit: a = a + 1 if a % 2== 0: yield a
for num in num\_pairs(10): print(num)
\#numeros inparesdef num\_2(limit): a = 0 while a < limit: a = a + 1 if a % 2!= 0: yield a
for num in num\_2(10): print(num)
Hola, porque se debe crear un iterador y, en cambio, no se itera directamente?
Hacer esto:
text = "Hola"
iter\_text = iter(text)
for char in iter\_text:
print(char)
y no esto:
for character in text:
print(character)
Adjunto mi versión del reto de Pepsi.
impresión:
```python
print("AQUI INICIAN NUMEROS PARES")
def pares(limit):
a = 0
while a<limit:
yield a
a+=2
for num in pares(20):
print(num)
print("AQUI INICIAN NUMEROS IMPARES")
def impares(limit):
a = 1
while a<limit:
yield a
a+=2
for num in impares(20):
print(num)
```Aqui mi aporte al reto, muchas gracias!
Sería bueno explicar a mayor detalle la línea de código 8 en la sucesión de Fibonacci. Para los que venimos detalle otros lenguajes, vemos necesario el crear una variable temporal para asignarla al valor de la variable b en este caso, pero veo que en Python en particular no es necesario.
Me explico:
En JavaScript por ejemplo, sería de esta manera, suponiendo que tenemos los siguientes valores:
let a = 1
let b = 2
// cambiando los valores
let temp = a + b // 1 + 2 = 3
a = b // 2
b = temp // 3
En Python ya no se requiere la variable temporal:
a = 1
b = 2
a, b = b, a + b
Para a: asigna el valor de la variable b (ahora a vale 2)
Para b: suma el valor anterior de a (1) con b (2) y lo asigna a b (ahora b vale 1+2=3) sin necesidad de una variable temporal.
Tuve que investigarlo un poco a detalle en ChatGPT ya que como mencionaba, es un poco confuso al venir de lenguajes como JavaScript. Creo que eso es lo interesante de Python, su simplicidad al estructurar código.
Les recomiendo investigar más sobre prácticas de Pythonic Way, donde podrán comprender más sobre su simplicidad.
Saludos!
def nongen(limit):
a = 1
for a in range(1, limit+1, 2):
yield a
for num in nongen(50):
print(num)
esta puede ser una forma de funcion para obtener impares con limite
Aquí mi reto de creación de generador de numros para e impares:# Generador de números imparesdef odd\_numbers\_generator (start, limit): if start%2 == 0: start += 1
while start < limit: yield start start += 2
for num in odd\_numbers\_generator(5, 15): print(num)
\# Generador de números imparesdef even\_numbers\_generator (start, limit): if start%2 != 0: start += 1
while start < limit: yield start start += 2
for num in even\_numbers\_generator(5, 15): print(num)
```js
# Generador de números impares
def odd_numbers_generator (start, limit):
if start%2 == 0:
start += 1
while start < limit:
yield start
start += 2
for num in odd_numbers_generator(5, 15):
print(num)
# Generador de números impares
def even_numbers_generator (start, limit):
if start%2 != 0:
start += 1
while start < limit:
yield start
start += 2
for num in even_numbers_generator(5, 15):
print(num)
```
```js
def eveNNum(lim):
num=0
while num < lim:
yield num
num+=2
def oddNum(lim):
num=1
while num < lim:
yield num
num+=2
for e in eveNNum(10):
print(e)
for o in oddNum(10):
print(o)
```def eveNNum(lim): num=0 while num < lim: yield num num+=2
def oddNum(lim): num=1 while num < lim: yield num num+=2
for e in eveNNum(10): print(e)
for o in oddNum(10): print(o)
Mi aporte al reto propuesto, con la entrada al generador par se puede decidir si se quieren generar pares o impares, haciendo uso de la misma funcion 
aporte del ejercicio
```python
#Ejercicio crear generadores para imprimir numeros pares e impares
print("\n", "--------------------------------------------------")
print("Generators -> función que crea una lista de números e imprime los pares y los impares")
def str_numbers_even_odd(limit):
iter_numbers_evens = iter(range(0, limit+1, 2))
iter_numbers_odds = iter(range(1, limit+1, 2))
str_even = ''
for i in iter_numbers_evens:
if str_even != '':
str_even = str_even + ', ' + str(i)
else:
str_even = str(i)
str_odd = ''
for i in iter_numbers_odds:
if str_odd != '':
str_odd = str_odd + ', ' + str(i)
else:
str_odd = str(i)
print(str_even)
print(str_odd)
def generator_number_even(limit):
iter_numbers_evens = iter(range(0, limit+1, 2))
for i in iter_numbers_evens:
if i != 0:
yield i
def generator_number_odd(limit):
iter_numbers_odds = iter(range(1, limit+1, 2))
for i in iter_numbers_odds:
yield i
def print_numbers_even_odd(limit):
for element in generator_number_even(limit):
print(element)
print('-----------------------------------------')
for element in generator_number_odd(limit):
print(element)
str_numbers_even_odd(10)
print('\n')
print_numbers_even_odd(10)
```
`range(1, limite + 1, 2)` le indica a Python que comience en 1 (el primer número impar) y avance hasta `limite + 1` (11), incrementando de 2 en 2. Esto crea la secuencia de números impares: `[1, 3, 5, 7, 9]`.
Les comparto mi reto saludos
```python
#First we have to make a generator for even numbers
def evens(limit):
a, b = 0, 2
while a< limit:
yield a
a = a + b
for num in evens(20):
print(num)
#Now one for odd numbers
def odds(limit):
a, b = 1, 2
while a< limit:
yield a
a = a + b
for numod in odds(20):
print(numod)
```Aporte para el ejercicio de la clase
Mi aporte para el ejercicio de la clase #First we have to make a generator for even numbers
def evens(limit): a, b = 0, 2 while a< limit: yield a a = a + b
for num in evens(20): print(num) #Now one for odd numbers
def odds(limit): a, b = 1, 2 while a< limit: yield a a = a + b
for numod in odds(20): print(numod)```js
#First we have to make a generator for even numbers
def evens(limit):
a, b = 0, 2
while a< limit:
yield a
a = a + b
for num in evens(20):
print(num)
#Now one for odd numbers
def odds(limit):
a, b = 1, 2
while a< limit:
yield a
a = a + b
for numod in odds(20):
print(numod)
```
Generado\_números\_pares
```js
#Crear generadores para ver números pares
limite = int(input("Ingrese un límite: "))
def par(limite):
a,b, = 1,2
for i in range (0,limite):
if i%2!=0:
yield a
a+=1
else:
a+=1
for num in par(limite):
print("Número par", num)
```Generador\_números\_impares
```js
#Crear generadores para ver números impares
limite = int(input("Ingrese un límite: "))
def par(limite):
a,b, = 1,2
for i in range (0,limite):
if i%2==0:
yield a
a+=1
else:
a+=1
for num in par(limite):
print("Número impar", num)
```
```js
#generadores para ver los numeros pares e impares.
def par(inicio, fin):
n=inicio
while(n < fin):
if n%2==0 :
yield n
n +=1
def impar(inicio, fin):
n=inicio
while(n < fin):
if n%2 !=0 :
yield n
n +=1
for n in par(0, 35):
print(n)
for n in impar(4,14):
print(n)
```
Hola, comparto la respuesta al reto :)
```js
def numeros(limit):
a = 1
while a <= limit:
if a % 2 == 0:
print("Es un número par: ", a)
else:
print("No es un número par: ", a)
yield a
a += 1
for num in numeros(20):
pass
```
### Ventajas de los generadores:
1. **Eficiencia en memoria**: Los generadores producen los elementos uno a uno, por lo que son extremadamente eficientes cuando se trabaja con secuencias grandes o infinitas.
2. **Lazy evaluation (evaluación perezosa)**: Los valores no se calculan de inmediato, sino cuando se requieren. Esto es muy útil cuando se procesan grandes volúmenes de datos o secuencias infinitas.
3. **Código más limpio y sencillo**: Usar `yield` en lugar de mantener manualmente el estado interno en una función iteradora hace que el código sea más simple y legible.
### Diferencias clave entre Iteradores y Generadores:
* **Iteradores**: Son objetos que implementan explícitamente los métodos `__iter__()` y `__next__()`.
* **Generadores**: Son funciones que utilizan `yield` para devolver elementos de forma paulatina y mantienen automáticamente su estado interno.
### ¿Cuándo usar cada uno?
* **Iteradores**: Son útiles si necesitas definir un objeto iterable complejo y deseas un control manual sobre cómo se recorren sus elementos.
* **Generadores**: Son más fáciles de crear cuando necesitas producir una secuencia de elementos, especialmente si la secuencia es grande o infinita.
Ambas herramientas son fundamentales para el procesamiento eficiente de datos en Python
Números Pares e Impares
```js
def num_parimpar(limit):
num = 0
for num in range(limit):
if num % 2 == 0:
yield num
else:
yield num
for num in num_parimpar(20):
print(num)
```
Ejercicio de generadores de números pares e impares:
\#Números pares
print('Generador de números pares')
def par (limit):
a = 0
while a < limit:
yield a
a += 2
for num in par(20):
print(num)
\#Números impares
print('Generador de números impares')
def impar (limit):
a = 1
while a < limit:
yield a
a += 2
for num in impar(20):
print(num)
Así me quedó el ejercicio de números pares e impares:
def impar(limit): a = 1 while a < limit: yield a a = a + 2
def par(limit): a = 0 while a < limit: yield a a = a + 2
operacion = input("Digite si desea obtener los números pares o impares: ")limite = int(input(f"Digite hasta que número desea calcular los números {operacion}: "))
if operacion.startswith("i"): for imp in impar(limite+1): print(f"Los números impares del 1 al {limite} son: " , imp)else: for par in par(limite+1): print(f"Los números pares del 1 al {limite} son: " , par)```python
def impar(limit):
a = 1
while a < limit:
yield a
a = a + 2
def par(limit):
a = 0
while a < limit:
yield a
a = a + 2
operacion = input("Digite si desea obtener los números pares o impares: ")
limite = int(input(f"Digite hasta que número desea calcular los números {operacion}: "))
if operacion.startswith("i"):
for imp in impar(limite+1):
print(f"Los números impares del 1 al {limite} son: " , imp)
else:
for par in par(limite+1):
print(f"Los números pares del 1 al {limite} son: " , par)
```
El siguiente generador permite la creación tanto de números pares como impares, de acuerdo a la opción seleccionada.
Hola a todos, les envío la solución de los generdores de números pares e impares:
\# Crear generador para números pares e impares
\# Generador de números pares
def pares(limite):
a = 0
while a <= limite:
if a % 2 == 0 :
yield a
a +=1
for num in pares(11):
print(num)
\# Generador de númerps impares
def impares(limite):
a = 0
while a <= limite:
if a % 2 != 0 :
yield a
a +=1
for num in impares(11):
print(num)
Espero que les haya servido
Los iteradores y los generadores son objetos y funciones que permiten recorrer valores de manera eficiente,
El generador es un tipo especial de función que no devuelve un único valor: devuelve un objeto iterador con una secuencia de valores
Mi pequeña aportacion:
lista = \[1,2,3,4,5,6,7,8,9,10]
iter\_list = iter(lista)
for n in iter\_list:
if n % 2 == 0:
print("numeros pares son")
print(n)
elif n % 2 != 0:
print("numeros impares")
print(n)
Tengo duda de cómo funciona aún el YIELD, porque en el ejemplo de Fibonacci no comprendo como funciona y porque se asigna a la variable "a".
Les agradecería que me apoyen con un ejemplo o explicación.
```python
# resubo mi respuesta al reto porque la otra se ve fea
# generador de impares
def odd_generator(limit):
a = 0
while a < limit:
if a % 2 == 1:
yield a
a += 1
# generador de pares
def even_generator(limit):
a = 0
while a < limit:
if a % 2 == 0:
yield a
a += 1
```def odd\_generator(limit):
a = 0
while a < limit:
if a % 2 == 1:
yield a
a += 1
Por aquí mi aporte para resolver el reto
`#generador de impares`
`def odd_generator(limit):`
`a = 0`
`while a < limit:`
`if a % 2 == 1:`
`yield a`
`a += 1`
`#generador de pares`
`def even_generator(limit):`
`a = 0`
`while a < limit:`
`if a % 2 == 0:`
`yield a`
`a += 1`
Por que le pone +1 al limit
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!
```python
# Generators
def even_or_odd_numbers(n, is_odd=False):
of = 1 if is_odd else 0
for number in range(n):
if number % 2 == of:
yield number
```# Generatorsdef even\_or\_odd\_numbers(n, is\_odd=False): of = 1 if is\_odd else 0 for number in range(n): if number % 2 == of: yield number
Mi aporte
Mi solución al reto:
```python
def generate_numbers(limit,start):
numbers = iter(range(start, limit+1,2))
for num in numbers:
yield num
for number in generate_numbers(10,0):
print(number)
```def generate\_numbers(limit,start): numbers = iter(range(start, limit+1,2)) for num in numbers: yield num
for number in generate\_numbers(10,0): print(number)
**Código:**
```python
def generator_numbers(start, limit):
while start < limit + 1:
yield start
start += 2
print("Numeros Pares")
my_list = list(generator_numbers(0, 10))
print(my_list)
print("Numeros Impares")
my_list = list(generator_numbers(1, 10))
print(my_list)
```
**Output:**
Mi aporte:
```python
def generador_odd(init_num, limit):
a = init_num
while a <= limit:
yield a
a = a + 2
init_num = int(input("Ingresa un numero par inicial para hallar los numeros pares que le siguen, o uno impar para hallar los numeros impares siguientes: "))
last_num = int(input("Ingresa el numero maximo hasta el que deseas se hallen estos numeros: "))
if(init_num <= last_num):
orden = "pares" if init_num%2 == 0 else 'impares'
print(f"Los numeros {orden} siguientes a {init_num} son:")
for i in generador_odd(init_num, last_num):
print(i)
else:
print(f"{init_num} es menor que {last_num}")
print("El numero inicial debe ser mayor que el numero maximo.")
```
Reto completado:
```js
print("----------------------------------------------------")
# Generador de numeros impares
def odd(n):
for i in range(1, n, 2):
yield i
n = input("Ingrese el numero máximo para impares: ")
for i in odd(int(n)):
print(i)
#Generador de numeros pares
print("----------------------------------------------------")
def odd(h):
for i in range(0, h, 2):
yield i
h = input("Ingrese el numero máximo para pares: ")
for i in odd(int(h)):
print(i)
```print("----------------------------------------------------")# Generador de numeros imparesdef odd(n): for i in range(1, n, 2): yield in = input("Ingrese el numero máximo para impares: ") for i in odd(int(n)): print(i) #Generador de numeros paresprint("----------------------------------------------------")def odd(h): for i in range(0, h, 2): yield ih = input("Ingrese el numero máximo para pares: ")for i in odd(int(h)): print(i)
mi código:
\#Generador de ver número pares:def num\_pares(limit): a=0 while a < limit+1: yield a a=a+2
for num in num\_pares(10): print(num)
\#Generador de númros impares
def num\_impar(limit): a=1 while a < limit+1: yield a a = a+2
for num in num\_impar(11): print(num)
Mi respuesta al reto:
PARA NÚMEROS PARES:
def pares(limit):
a = 2
while a
Mi aporte
```js
#Generador de pares y impares
def reto(limit):
a = 0
while a < limit:
yield a
a +=1
for num in reto(20):
if num%2==0:
print("Par",num)
else:
print("Impar",num)
```
Aquí dejo mi aporte del generador de números pares.
```js
def parNumbers(limit):
x = 0
while x < limit:
x += 2
yield x
for parNumber in parNumbers(60):
print(parNumber)
```def parNumbers(limit): x = 0
while x < limit: x += 2 yield x
for parNumber in parNumbers(60): print(parNumber)
La función parNumbers actúa como el generador, el cual resive como parámetro el límite, y dentro contine la variable x que al principio se inicializa como 0. Luego hay un while que mientras x sea menor al límite, le sumará 2 unidades a x y retornará el valor de x.
El for fuera sólo ejecuta las veces que sean indicadas en el límite y guarda los datos en parNumber para así luego imprimirlas en terminal.
Mi aporte al reto con generadores
```js
#Generador par
print ("Generador con pares")
def pares ( limitpar):
a,b = 0, 2
while a < limitpar:
yield a
a,b = b, a + b
for num in pares (10):
print (num)
#Generador impar
print ("Generador con impares")
def pares ( limitpar):
a,b = 1, 3
while a < limitpar:
yield a
a,b = b, a + b
for num in pares (10):
print (num)
```
Para quienes se preguntas por que colocó limit+1 en *odd\_iter= iter(range(1,limit+1,2))*, es porque en range, el inicio es incluyente, pero el final es excluyente. No era necesario para los números impares, pero si para que el 10 se mostrara en los pares. Recuerden que range puede contener tres valores, los cuales son: range(inicio,fin,paso)
Hola a todos.
```python
#generador de numeros par e impares
def generador_impar(limite):
a = 1
while a < limite:
a +=2
yield a
for i in generador_impar(17):
print("Numeros impares:",i)
def generador_par(limite):
a = 0
while a < limite:
a +=2
yield a
for i in generador_par(18):
print("Numeros pares:",i)
```#generador de numeros par e impares
def generador\_impar(limite): a = 1 while a < limite: a +=2 yield a
for i in generador\_impar(17): print("Numeros impares:",i)
def generador\_par(limite): a = 0 while a < limite: a +=2 yield a
for i in generador\_par(18): print("Numeros pares:",i)
Increíble está clase, aprendí mucho.
# funcion par o inpar por limite
# tipo 0 para pares
# tipo mayor ó igual a 1 para inpares
def funcion(limite,tipo):
if tipo== 0:
a=2
else:
a=1
while a< limite:
yield a
a= a+2
print('pares')
for num in funcion(10,0):
print(num)
print('impares')
for num in funcion(10,1):
print(num)
Aquí dejo mi aporte al reto
```js
#generador numeros pares e impares
def pares(limit):
#el usuario introduce el numero par o impar
a = int(input('Elige un numero par o impar menor de 10 para continuar la sucesion, segun tu eleccion:'))
#se evalua segun el limite indicado y se le suma 2
while a <= limit:
yield a
a += 2
#se repite el ciclo hasta llegar al limite
for num in pares(20):
print(num)
```
```js
def par():
pares = iter(range(0,limite + 1, 2))
for par in pares:
print(par)
def impar():
impares = iter(range(1,limite + 1, 2))
for impar in impares:
print(impar)
limite = int(input("Ingrese un número: "))
if limite % 2 == 0:
par()
else:
impar()
```def par(): pares = iter(range(0,limite + 1, 2)) for par in pares: print(par) def impar(): impares = iter(range(1,limite + 1, 2)) for impar in impares: print(impar) limite = int(input("Ingrese un número: "))if limite % 2 == 0: par()
else: impar()
`def par():`
` pares = iter(range(0,limite + 1, 2))`
` for par in pares:`
` print(par)`
` `
`def impar():`
` impares = iter(range(1,limite + 1, 2))`
` for impar in impares:`
` print(impar)`
` `
`limite = int(input("Ingrese un número: "))`
`if limite % 2 == 0:`
` par()`
`else:`
` impar()`
Mi aporte para el reto:
**Aclaración:**
**¿Que son los generadores?**
como el propio nombre indica, sirven para **generar** datos *<u>en tiempo de ejecución</u>*. Además también podemos acelerar búsquedas y crear bucles más rápidos.
Para construir generadores sólo tenemos que usar ***<u>yield</u>***. Esta orden devolverá un valor (igual que hace *return*)... peeeeero, congelará la ejecución de la función hasta la próxima vez que le pidamos un valor. En cambio, return rompe la ejecución.
Mi aporte al reto.
```python
# Generar números pares
def num_par(limit):
par = 2
while par < limit + 2:
yield par
par += 2
pregunta_par = int(input("¿Hasta que número par desea visualizar?: "))
for num in num_par(pregunta_par):
print(num)
# Generar números impares
def num_impar(limit):
impar = 1
while impar < limit + 2:
yield impar
impar += 2
pregunta_par = int(input("¿Hasta que número impar desea visualizar?: "))
for num in num_impar(pregunta_par):
print(num)
```
Buena noche dejo mi aporte al reto de la clase
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?