La sucesión de Fibonacci

Clase 13 de 21 • Curso Profesional de Python

David Guerrero Morales Guerrero

student•

from time import sleep
class FiboIter():

    def __init__(self, max_number:int):
        self.max_number = max_number
    
    def __iter__(self):
        self.n1 = 0
        self.n2 = 1
        self.counter = 0
        return self
    
    def __next__(self):

        if self.counter == 0:
            self.counter += 1
            return self.n1
        elif self.counter == 1:
            self.counter += 1
            return self.n2
        else:
            self.aux = self.n1 + self.n2
            
            if self.aux >= self.max_number:
                raise StopIteration
            
            self.n1, self.n2 = self.n2, self.aux
            self.counter += 1
            return self.aux
        


if __name__ == "__main__":
    for element in FiboIter(39):
        print(element)
        sleep(0.1)

Kenny Rogger Canahualpa Patilla

student•

Si bien es cierto tu codigo funciona con un atributo de instancia, cuando este no tiene un atributo de instancia el codigo no funciona:

Para solucionar esto y funcione con o sin un atributo de instancia: "talvez no se el codigo mas eficiente en términos de ahorro de lineas de codigo, pero funciona"

Dennis Alejandro Salinas Estrada

student•

Me inspire en sus comentarios para mi solucion, ademas de que tambien son menos lineas. Que opinan?

Fabricio González Guasque

student•

Mi aporte al reto! Saludos

No puse el output porque es lo mismo que lo visto en la clase, solamente que se detiene cuando llegamos al numero que le pasamos.

Reinaldo Mendoza

student•

Muchas gracias por compartir

David Silva Apango

student•

¿Y si el máximo fuera 0 ó 1?

Cristian Bastidas

student•

Adicionalmente a la sucesión de Fibonacci hice un iterador que obtiene los números primos que existen hasta cierto n. Me parece increíble lo que se puede hacer con los iteradores. 😮

!Números Primos

Mauricio Gonzalez Falcon

student•

Genial tu aporte Cristian. Lo único que puedo darte feedback, es que sí el usuario no ingresa un límite, es decir, infinito.

Como respondería el programa, saludos!

Dennis Alejandro Salinas Estrada

student•

Este es mi solucion, funciona con o sin numero maximo. Decidi hacerlo asi gracias a un comentario que mire.

import time

class FiboIter():
    
    def __init__(self, max=None):
        self.max = max

    def __iter__(self):
        self.n1 = 0
        self.n2 = 1
        self.counter = 0
        return self
        
    def __next__(self):
        if self.counter == 0:
            self.counter += 1
            return self.n1
        elif self.counter ==1:
            self.counter += 1
            return self.n2
        else:
            self.aux = self.n1 + self.n2
            self.counter += 1
            self.n1, self.n2 = self.n2, self.aux
            if not self.max:
                return self.aux, self.counter

            if self.max:
                if self.aux > self.max:
                    raise StopIteration
                else:
                    return self.aux, self.counter

if __name__ == '__main__':
    for element in FiboIter():
        print(element)
        time.sleep(.05)

Una duda que me surgio fue el de como acceder opcionalmente al contador, ya que en el codigo se agrega pero no encontre forma de acceder a el en el codigo como e esta. ademas de cuestionarme su empleo ya que no parece tener algun tipo de utilidad.

Salvador Sebastian Márquez Herrera

student•

Dennis tu código me ayudo mucho, por cierto no es necesario que retornes el contador, con el aux basta para que no te imprima una tupla :)

Alberto Enrique Alonso De la Hoz

student•

Puedes acceder al indice de la iteración, que en este caso es igual al atributo self.counter de tu clase, utilizando la función enumerate(<iterador>) dentro del for. Siguiendo tu ejemplo:

for index, element in enumerate( FiboIter() ):
        print(element)
        print(index)
        time.sleep(.05)

Bryan

student•

Como detengo la consola?

Yair Hernández

student•

ctrl+C

Andrés López

student•

Con ctrl + C

Jonathan Edwin Gutiérrez Olvera

student•

Una solución simple y eficaz 😁

Arturo Escobar Fernandez

student•

Exacto, la respuesta estaba justo en la clase anterior, no entendí por que se mencionaba en la clase que el reto era difícil. Buena!

Kenneth Henry Meier Oborski

student•

Con que programa haces que el codigo te salga de esa manera ?

Francisco Moreno

student•

This is my code. Please comment any error did you’ll find.

<import time 

class Fibonacci():

    def __init__(self, nmax):
        self.nmax = nmax
        
    def __iter__(self):
        self.num1 = 0
        self.num2 = 1
        self.counter = 0 
        return self

            
    
    def __next__(self):

        if self.counter == 0:
            self.counter += 1 
            return self.num1

        elif self.counter == 1:
            self.counter += 1
            return self.num2
        
        else:

            self.aux = self.num1 + self.num2 

            # Like a break; if the aux > nmax: stop, nmax is the limit.
            if self.aux > self.nmax:
                print('Finished.')
                raise StopIteration
                
            self.num1, self.num2 = self.num2, self.aux 
            self.counter += 1 
            return self.aux 
        
        
def run():
  
    try:
        nmax = int(input('Introduce the max limit number that can iterate this function: \n'))
        
        if nmax > 0:
            fibonacci = Fibonacci(nmax)
            for element in fibonacci:
                print(f' \n{element}')
                time.sleep(1)

        elif nmax == 0:
            print(0)

        else:
            print('Introduce a positive number.') 
            run()
            
    except ValueError as ve:
        print('Only integer and positive numbers.')
        run()
   
if __name__ == '__main__':
    run()
   
    >

Luis Alejandro Vera Hernandez

student•

Gracias, me ayudo tu ejemplo, lo vi muy bueno, aunque yo le puse para que imprima la cantidad de ciclos que ingrese el usuario, el tuyo creo que compara la cantidad maxima del usuario con el primer numero al que llegue la sucesion.

Cesar Hernández Ramírez

student•

Algo que descubrí al estar haciendo el reto es podemos inicializar un iterador solo con el método next, pero fallará porque no tendrá los atributos que declaremos en el metodo iter. Y lo curioso es que nosotros no podemos utilizar __iter__() para inicializar el iterador como haciamos con iter(objeto) . En cambio con __next__() sí podremos ir avanzadando por cada elemento del iterador 👍

Luis Felipe Bravo Hernández

student•

Cuando me encontre este problema, lo resolvi llamando a __ iter __ desde __ init __:

def __init__(self, max=None):
	self.max = max
	self.__iter__()

Juan Carlos Ruiz Montaño

student•

import time

class FiboIter():
   
   def __init__(selft, max = None):
      if max == None:
         selft.max = None
      else:
         selft.max = max
   
   def __iter__(selft):
      selft.n1 = 0
      selft.n2 = 1
      selft.counter = 0
      return selft
   
   def __next__(selft):
      def fibo(): #funcion fibonacci
         selft.aux = selft.n1 + selft.n2
         #selft.n1 = selft.n2
         #selft.n2 = selft.aux
         selft.n1, selft.n2 = selft.n2, selft.aux
         selft.counter += 1
         return selft.aux
      
      if selft.counter == 0:
         selft.counter += 1
         return selft.n1
      elif selft.counter == 1:
         selft.counter += 1
         return selft.n2
      elif selft.max == None:
         return fibo() #ejecucion infinita
      elif selft.counter >= selft.max:
         raise StopIteration
      else:
         return fibo()#ejecucion controlada

if __name__ == "__main__":
   fibonacci = FiboIter()
   i  = 0
   for element in fibonacci:
      print(str(i) + " Vueltas")
      print(element)
      time.sleep(0.05)
      i += 1

Jesús Ramón Beltrán Chan

student•

Como sugerencia, en la primer condición del constructor si max es igual a None, no es necesario volver a asignarle None, puedes usar algo asi en su lugar:

if max is not None:
    assert max > 0, "max debe ser mayor que 0"
self.max = max

Tomás Retamal Venegas

student•

Para saber si entendí bien, ¿Un iterable es una instancia de un iterador? Es decir, si un iterador se define como una clase, entonces ¿Al instanciarlo obtenemos un iterable?

Fernando Hernandez

student•

Es así ...

José Rodrigo Arana Hi

student•

¿Por qué el método dunder next puede tomar los atributos de dunder inter? ¿Qué no están en un scope diferente?

Jonathan Sánchez Luna

student•

Porque se trata de métodos de una clase, y al instanciar dicha clase, todos sus atributos se encuentran en el scope de la clase, así todos sus métodos los pueden accesar.

José Rodrigo Arana Hi

student•

Imaginé que el self (o la instancia) tenía algo que ver. Muchas gracias Jonny, es bueno saber que hay alguien más de BC estudiando (por lo de TJ). Salu2 desde Mxli.

Gustavo Adolfo Perez Ramos

student•

Yuri Ochoa

student•

¡Hola! Dejo mi aporte, estoy en proceso de aprendizaje...agradezco sus comentarios para poder mejorar el programa.

Carlos Arturo Gonzalez Meyberg

student•

Haciendo la prueba de escritorio funciona

Adriana Razo De León

student•

Hola se aceptan comentarios, no soy nada experta...

Adriana Razo De León

student•

ups! mi error fue que lo limité al número de fibonacci y no a la posición de la serie...

Pablo .

student•

import time

class FiboIter():

    def __init__(self, max=None):
        self.max = max

    def __iter__(self): 
        self.n1 = 0
        self.n2 = 1
        self.counter = 0
        return self 

    def __next__(self):
        if not self.max or self.counter <= self.max:
            if self.counter == 0:
                self.counter += 1
                return self.n1
            elif self.counter == 1:
                self.counter += 1
                return self.n2
            else:
                self.aux = self.n1 + self.n2
                
                self.n1, self.n2 = self.n2, self.aux
                self.counter += 1
                return self.aux
        else:
            raise StopIteration

#Visualizar en consola
if __name__ == '__main__':
    fibonacci = FiboIter(25)
    for idx, element in enumerate(fibonacci):
        print(idx, " ", element)
        time.sleep(0.05)

Elliot Ramirez

student•

Gracias por tu aporte... indexarlo lo mejor

Alberto Enrique Alonso De la Hoz

student•

Lo quise hacer de esta manera. Utilicé atributos privados en la clase agregando "__" al inicio de sus nombres. Me pareció correcto inicializar las variables de los números en el constructor y dejar solamente el contador en el método iter(). No se que opinen de esto último.

class Fibonacci:
    def __init__( self,upper ):
        self.__upper = upper
        self.__num1 = 0
        self.__num2 = 1

    def __iter__( self ):
        self.__counter = 0
        return self
        
    def __next__( self ):
        if self.__counter < self.__upper:
            returned = self.__num1
            self.__num1 = self.__num2
            self.__num2 += returned
            self.__counter += 1
            return returned
        else:
            raise StopIteration

if __name__ == '__main__':
    for i in Fibonacci(20):
        print(i,end=" ")

Alex Junior Rodriguez Huerta

student•

Este es mi aporte, entendí que el usuario debería llenar el máximo valor y este debe parar.

import time

class FiboIter():

    def __init__(self, max = int(input("Ingresa un valor: "))):
        self.max = max

    def __iter__(self):
        self.n1 = 0
        self.n2 = 1
        self.counter = 0
        self.cnt = 0
        return self

    def __next__(self):
        if not self.max or self.n1 + self.n2 <= self.max:
            if self.counter == 0:
                self.counter += 1
                return self.n1
            elif self.counter == 1:
                self.counter += 1
                return self.n2
            else: 
                self.aux = self.n1 + self.n2
                self.n1, self.n2 = self.n2, self.aux
                self.counter += 1
                return self.aux
            
        else:
            raise StopIteration
        

if __name__ == "__main__":
    fibonacci = FiboIter()
    for element in fibonacci:
        print(element)
        time.sleep(1)

Bryan Estiven Silva Mercado

student•

import time

class fiboIter():
    
    def __init__(self,max):
        self.max = max
    
    def __iter__(self):
        self.number1 = 0
        self.number2 = 1
        self.counter = 0
        return self
    
    def __next__(self):
        if self.counter == 0:
            self.counter +=1
            return self.number1
        elif self.counter == 1:
            self.counter +=1
            return self.number1
        elif self.number2 < self.max:
            self.aux = self.number1 + self.number2
            """ esto <self.number1 = self.number2
            self.number2 = self.aux> se puede reducir de la siguiente forma """
            
            self.number1, self.number2 = self.number2, self.aux
            self.counter +=1
            return self.aux
        else:
            raise StopIteration
        

if __name__ == "__main__":
    
    fibonacci = fiboIter(1597)
    
    for element in fibonacci:
        print(element)
        time.sleep(1)

María Camila Fernández Espinel

student•

No se si lo que hice esta bien, acepto cualquier tipo de comentarios :P

import time

class Fiboiter():

    def __init__(self, max = None) -> None:
        self.max = max 
        self.aux = 0

    def __iter__(self):
        self.n1 = 0
        self.n2 = 1
        self.counter = 0
        return self

    def __next__(self):
        if self.counter == 0:
            self.counter += 1
            return self.n1
        elif self.counter == 1:
            self.counter += 1
            return self.n2
        elif self.aux <= self.max:
            self.aux = self.n1 + self.n2
            # self.n1 = self.n2
            # self.n2 = self.aux 
            self.n1, self.n2 = self.n2, self.aux
            self.counter += 1
            return self.aux
        
        elif self.aux >= self.max:
                raise StopIteration


if __name__ == "__main__":
    max = int(input("Enter the max of the Fibonacci sucession's: "))
    fibonacci =  Fiboiter(max)
    for element in fibonacci:
        print(element)
        time.sleep(0.05)

Diego Fernando Pedraza Cardenas

student•

Veo dos detalles en tu código, cuando no ingresas un argumento es decir None el te da el error que debes ingresar un valor numérico, en mi caso lo deje para que si no ingresas nada el te de números hasta infinito y lo otro es que siempre te imprime un numero después del máximo, si haces la prueba por ejemplo con 6 el te alcanza a imprimir 8.

Ariel Ricardo Cornejo Jiménez

student•

Hola, alguien puede correr mi codigo y ayudarme a ver que hice mal?

el counter aumenta bien pero queda en loop el programa , no entra a la exception

import time


class FiboIter():

    '''Clase que realiza la sucesion de fibonacci
    hasta un numero maximo'''

    def __init__(self, max=None):

        self.max = max 


    def __iter__(self):
        self.n1 = 0
        self.n2 = 1
        self.counter = 0 
        return self 



    def __next__(self):

        if self.max != None:
            print("valor max-> ", self.max, " - ", " counter-> ", self.counter)
        else:   
            max = input("ingrese numero maximo de la sucesion: ")
            self.max = max   


        if self.counter == self.max:
            print("max y counter iguales")
            raise StopIteration
            
            
          
        elif self.counter == 0:
                self.counter += 1
                return self.n1
        
        elif self.counter == 1:
            self.counter += 1
            return self.n2
        
        else:
            self.aux = self.n1 + self.n2
            # self.n1 = self.n2
            # self.n2 = self.aux
            
            self.n1 , self.n2 = self.n2, self.aux #swapin' values 
            self.counter += 1
            return self.aux


 

if __name__ == '__main__':
    
    
    
    fibonacci = FiboIter()

    for element in fibonacci:
        print(element)
        time.sleep(1)

Pablo Antipan Quiñenao

student•

Hola! Faltaba transformar el input a integer:

import time


class FiboIter:

    """Clase que realiza la sucesion de fibonacci
    hasta un numero maximo"""

    def __init__(self, max=None):

        self.max = max

    def __iter__(self):
        self.n1 = 0
        self.n2 = 1
        self.counter = 0
        return self

    def __next__(self):

        if self.max != None:
            print("valor max-> ", self.max, " - ", " counter-> ", self.counter)
        else:
            max = input("Ingrese numero maximo de la sucesion: ")

            self.max = max

        print(self.counter, self.max)
        if self.counter == int(self.max):
            print("max y counter iguales")
            raise StopIteration

        if self.counter == 0:
            self.counter += 1
            return self.n1

        elif self.counter == 1:
            self.counter += 1
            return self.n2

        else:
            self.aux = self.n1 + self.n2
            # self.n1 = self.n2
            # self.n2 = self.aux

            self.n1, self.n2 = self.n2, self.aux  # swapin' values
            self.counter += 1
            return self.aux


if __name__ == "__main__":

    fibonacci = FiboIter()

    for element in fibonacci:
        print(element)
        time.sleep(0.2)

Saludos!

Ariel Ricardo Cornejo Jiménez

student•

muchas gracias pablo, saludos!

from time import sleep
class FiboIter():

    def __init__(self, max_number:int):
        self.max_number = max_number
    
    def __iter__(self):
        self.n1 = 0
        self.n2 = 1
        self.counter = 0
        return self
    
    def __next__(self):

        if self.counter == 0:
            self.counter += 1
            return self.n1
        elif self.counter == 1:
            self.counter += 1
            return self.n2
        else:
            self.aux = self.n1 + self.n2
            
            if self.aux >= self.max_number:
                raise StopIteration
            
            self.n1, self.n2 = self.n2, self.aux
            self.counter += 1
            return self.aux
        


if __name__ == "__main__":
    for element in FiboIter(39):
        print(element)
        sleep(0.1)

import time

class FiboIter():
    
    def __init__(self, max=None):
        self.max = max

    def __iter__(self):
        self.n1 = 0
        self.n2 = 1
        self.counter = 0
        return self
        
    def __next__(self):
        if self.counter == 0:
            self.counter += 1
            return self.n1
        elif self.counter ==1:
            self.counter += 1
            return self.n2
        else:
            self.aux = self.n1 + self.n2
            self.counter += 1
            self.n1, self.n2 = self.n2, self.aux
            if not self.max:
                return self.aux, self.counter

            if self.max:
                if self.aux > self.max:
                    raise StopIteration
                else:
                    return self.aux, self.counter

if __name__ == '__main__':
    for element in FiboIter():
        print(element)
        time.sleep(.05)

<import time 

class Fibonacci():

    def __init__(self, nmax):
        self.nmax = nmax
        
    def __iter__(self):
        self.num1 = 0
        self.num2 = 1
        self.counter = 0 
        return self

            
    
    def __next__(self):

        if self.counter == 0:
            self.counter += 1 
            return self.num1

        elif self.counter == 1:
            self.counter += 1
            return self.num2
        
        else:

            self.aux = self.num1 + self.num2 

            # Like a break; if the aux > nmax: stop, nmax is the limit.
            if self.aux > self.nmax:
                print('Finished.')
                raise StopIteration
                
            self.num1, self.num2 = self.num2, self.aux 
            self.counter += 1 
            return self.aux 
        
        
def run():
  
    try:
        nmax = int(input('Introduce the max limit number that can iterate this function: \n'))
        
        if nmax > 0:
            fibonacci = Fibonacci(nmax)
            for element in fibonacci:
                print(f' \n{element}')
                time.sleep(1)

        elif nmax == 0:
            print(0)

        else:
            print('Introduce a positive number.') 
            run()
            
    except ValueError as ve:
        print('Only integer and positive numbers.')
        run()
   
if __name__ == '__main__':
    run()
   
    > 

import time

class FiboIter():
   
   def __init__(selft, max = None):
      if max == None:
         selft.max = None
      else:
         selft.max = max
   
   def __iter__(selft):
      selft.n1 = 0
      selft.n2 = 1
      selft.counter = 0
      return selft
   
   def __next__(selft):
      def fibo(): #funcion fibonacci
         selft.aux = selft.n1 + selft.n2
         #selft.n1 = selft.n2
         #selft.n2 = selft.aux
         selft.n1, selft.n2 = selft.n2, selft.aux
         selft.counter += 1
         return selft.aux
      
      if selft.counter == 0:
         selft.counter += 1
         return selft.n1
      elif selft.counter == 1:
         selft.counter += 1
         return selft.n2
      elif selft.max == None:
         return fibo() #ejecucion infinita
      elif selft.counter >= selft.max:
         raise StopIteration
      else:
         return fibo()#ejecucion controlada

if __name__ == "__main__":
   fibonacci = FiboIter()
   i  = 0
   for element in fibonacci:
      print(str(i) + " Vueltas")
      print(element)
      time.sleep(0.05)
      i += 1

import time

class FiboIter():

    def __init__(self, max=None):
        self.max = max

    def __iter__(self): 
        self.n1 = 0
        self.n2 = 1
        self.counter = 0
        return self 

    def __next__(self):
        if not self.max or self.counter <= self.max:
            if self.counter == 0:
                self.counter += 1
                return self.n1
            elif self.counter == 1:
                self.counter += 1
                return self.n2
            else:
                self.aux = self.n1 + self.n2
                
                self.n1, self.n2 = self.n2, self.aux
                self.counter += 1
                return self.aux
        else:
            raise StopIteration

#Visualizar en consola
if __name__ == '__main__':
    fibonacci = FiboIter(25)
    for idx, element in enumerate(fibonacci):
        print(idx, " ", element)
        time.sleep(0.05) 

class Fibonacci:
    def __init__( self,upper ):
        self.__upper = upper
        self.__num1 = 0
        self.__num2 = 1

    def __iter__( self ):
        self.__counter = 0
        return self
        
    def __next__( self ):
        if self.__counter < self.__upper:
            returned = self.__num1
            self.__num1 = self.__num2
            self.__num2 += returned
            self.__counter += 1
            return returned
        else:
            raise StopIteration

if __name__ == '__main__':
    for i in Fibonacci(20):
        print(i,end=" ")

import time

class FiboIter():

    def __init__(self, max = int(input("Ingresa un valor: "))):
        self.max = max

    def __iter__(self):
        self.n1 = 0
        self.n2 = 1
        self.counter = 0
        self.cnt = 0
        return self

    def __next__(self):
        if not self.max or self.n1 + self.n2 <= self.max:
            if self.counter == 0:
                self.counter += 1
                return self.n1
            elif self.counter == 1:
                self.counter += 1
                return self.n2
            else: 
                self.aux = self.n1 + self.n2
                self.n1, self.n2 = self.n2, self.aux
                self.counter += 1
                return self.aux
            
        else:
            raise StopIteration
        

if __name__ == "__main__":
    fibonacci = FiboIter()
    for element in fibonacci:
        print(element)
        time.sleep(1)

import time

class fiboIter():
    
    def __init__(self,max):
        self.max = max
    
    def __iter__(self):
        self.number1 = 0
        self.number2 = 1
        self.counter = 0
        return self
    
    def __next__(self):
        if self.counter == 0:
            self.counter +=1
            return self.number1
        elif self.counter == 1:
            self.counter +=1
            return self.number1
        elif self.number2 < self.max:
            self.aux = self.number1 + self.number2
            """ esto <self.number1 = self.number2
            self.number2 = self.aux> se puede reducir de la siguiente forma """
            
            self.number1, self.number2 = self.number2, self.aux
            self.counter +=1
            return self.aux
        else:
            raise StopIteration
        

if __name__ == "__main__":
    
    fibonacci = fiboIter(1597)
    
    for element in fibonacci:
        print(element)
        time.sleep(1)

import time

class Fiboiter():

    def __init__(self, max = None) -> None:
        self.max = max 
        self.aux = 0

    def __iter__(self):
        self.n1 = 0
        self.n2 = 1
        self.counter = 0
        return self

    def __next__(self):
        if self.counter == 0:
            self.counter += 1
            return self.n1
        elif self.counter == 1:
            self.counter += 1
            return self.n2
        elif self.aux <= self.max:
            self.aux = self.n1 + self.n2
            # self.n1 = self.n2
            # self.n2 = self.aux 
            self.n1, self.n2 = self.n2, self.aux
            self.counter += 1
            return self.aux
        
        elif self.aux >= self.max:
                raise StopIteration


if __name__ == "__main__":
    max = int(input("Enter the max of the Fibonacci sucession's: "))
    fibonacci =  Fiboiter(max)
    for element in fibonacci:
        print(element)
        time.sleep(0.05)

import time

class FiboIter():

    '''Clase que realiza la sucesion de fibonacci
    hasta un numero maximo'''

    def __init__(self, max=None):

        self.max = max 

    def __iter__(self):
        self.n1 = 0
        self.n2 = 1
        self.counter = 0 
        return self 

    def __next__(self):

        if self.max != None:
            print("valor max-> ", self.max, " - ", " counter-> ", self.counter)
        else:   
            max = input("ingrese numero maximo de la sucesion: ")
            self.max = max   

        if self.counter == self.max:
            print("max y counter iguales")
            raise StopIteration
            
        elif self.counter == 0:
                self.counter += 1
                return self.n1
        
        elif self.counter == 1:
            self.counter += 1
            return self.n2
        
        else:
            self.aux = self.n1 + self.n2
            # self.n1 = self.n2
            # self.n2 = self.aux
            
            self.n1 , self.n2 = self.n2, self.aux #swapin' values 
            self.counter += 1
            return self.aux

if __name__ == '__main__':
    
    fibonacci = FiboIter()

    for element in fibonacci:
        print(element)
        time.sleep(1)

import time


class FiboIter:

    """Clase que realiza la sucesion de fibonacci
    hasta un numero maximo"""

    def __init__(self, max=None):

        self.max = max

    def __iter__(self):
        self.n1 = 0
        self.n2 = 1
        self.counter = 0
        return self

    def __next__(self):

        if self.max != None:
            print("valor max-> ", self.max, " - ", " counter-> ", self.counter)
        else:
            max = input("Ingrese numero maximo de la sucesion: ")

            self.max = max

        print(self.counter, self.max)
        if self.counter == int(self.max):
            print("max y counter iguales")
            raise StopIteration

        if self.counter == 0:
            self.counter += 1
            return self.n1

        elif self.counter == 1:
            self.counter += 1
            return self.n2

        else:
            self.aux = self.n1 + self.n2
            # self.n1 = self.n2
            # self.n2 = self.aux

            self.n1, self.n2 = self.n2, self.aux  # swapin' values
            self.counter += 1
            return self.aux


if __name__ == "__main__":

    fibonacci = FiboIter()

    for element in fibonacci:
        print(element)
        time.sleep(0.2)

La sucesión de Fibonacci

Introducción

¿Qué necesitas saber para tomar el curso?

¿Cómo funciona Python?

Cómo organizar las carpetas de tus proyectos

Static Typing

¿Qué son los tipados?

Tipado estático en Python

Practicando el tipado estático

Conceptos avanzados de funciones

Scope: alcance de las variables

Closures

Programando closures

Decoradores

Programando decoradores

Estructuras de datos avanzadas

Iteradores

La sucesión de Fibonacci

Generadores

Mejorando nuestra sucesión de Fibonacci

Sets

Operaciones con sets

Eliminando los repetidos de una lista

Bonus

Manejo de fechas

Time zones

Conclusión

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