Estudo de Caso | Python Fiddle

# -*- coding: cp1252 -*-
import pickle
import glob
import os

## Classe que define um investimento, que tem um nome,
## um custo inicial e um fluxo de caixa anual
## Caso haja a possibilidade de um reinvestimento por mais um ciclo,
## ele também tem um método que calcula o valor presente do investimento
## após N ciclos
class Investimento:
    def __init__(self, nome, investimento_inicial, fluxo_de_caixa):
        self.nome = nome
        self.investimento_inicial = investimento_inicial
        self.fluxo_de_caixa = fluxo_de_caixa
        self.duracao = len(fluxo_de_caixa)

## Método que calcula o valor presente após N ciclos de reinvestimento
    def CalcularValorPresenteNCiclos(self, N, juros):
        ## O VP inicial é igual ao custo do investimento inicial
        VP = self.investimento_inicial
        duracao_do_ciclo = len(self.fluxo_de_caixa)
        ## Calcula o VP para cada ciclo
        for ciclo in range(0,N):
            ## Calculando o VP do fluxo de caixa de cada ano
            ## E adiciona ao cálculo total do VP
            for ano in range(0,duracao_do_ciclo):
                ## Quando chegamos ao final de um ciclo, seu custo inicial é reinvestido
                ## ciclo < N-1 significa que é qualquer ciclo antes do último
                ## ano == duracao_do_ciclo - 1 significa que é o último ano do ciclo
                ## Porque no python, as listas começam pelo índice 0
                if ciclo < (N-1) and ano == duracao_do_ciclo - 1:
                    VP_fluxo_de_caixa = (self.fluxo_de_caixa[ano]+self.investimento_inicial)/((1+juros)**(1+ano+ciclo*duracao_do_ciclo))
                else:
                    VP_fluxo_de_caixa = self.fluxo_de_caixa[ano]/((1+juros)**(1+ano+ciclo*duracao_do_ciclo))
                ## Em ambos os casos, tendo o valor do fluxo de caixa naquele ano,
                ## encontra-se o valor presente desse fluxo de caixa
                ## dividindo o valor desse fluxo
                ## pelo desconto da taxa de juros
                ## que é igual a:
                ## (1+juros)^(ano em relação ao início dos investimentos)
                ##           (1+ano+ciclo*duracao_do_ciclo)
                ## nesse caso, esse ano corresponde ao número de ciclos já
                ## corridos, multiplicado pelo tamanho de cada ciclo
                ## somado ao ano correspondente ao fluxo de caixa dentro de cada ciclo
                ## Após calcular o VP do fluxo de caixa correspondente a esse ano, 
                VP += VP_fluxo_de_caixa
        self.VP = VP
        return VP

## Método que mostra informações de nome, custo inicial e duração do investimento
    def MostrarInformacoes(self):
        print("Nome do investimento: " + self.nome)
        print("Custo inicial do investimeto: (" + str(abs(self.investimento_inicial)) + ")")
        print("Duração do investimento: " + str(self.duracao) + " anos")
        ano = 1
        for fluxo in self.fluxo_de_caixa:
            print("Ano " + str(ano) + ": " + str(fluxo))
            ano += 1
        return
        
## Compara todos os investimentos registrados
## Como os investimentos podem ter horizontes de tempo diferenciados,
## A avaliação é feita pelo método do valor presente
## Assumindo que os investimentos são repetidos constantemente
## Até que todos os investimentos cheguem ao fim ao mesmo tempo
## A duração dessas repetições é feita encontrando o MMC das durações dos investimentos
## No final, obtém-se o VP de cada investimento após X anos, onde X é o MMC das durações dos investimentos
## O número de ciclos pelo qual cada investimento passa é igual a X/duração
## A taxa de juros é dada pelo usuário
## Os investimentos comparados são aqueles préviamente registrados
def CompararInvestimentos():
    ## Primeiramente, pergunta a taxa de juros
    juros = raw_input("Qual é a taxa de juros considerada (em valor decimal, por exemplo, 0.1)? \n")
    juros = float(juros)

## Cria uma lista e carrega todos os os objetos de investimentos que foram gravados
    investimentos = []
    for investimento in glob.glob("Investimentos/*.inv"):
        investimento = investimento.replace(".inv", "")
        investimento = investimento.replace("Investimentos\\", "")
        investimentos.append(CarregarInvestimento(investimento))

print("\n\n\n")
    ## Obtém o MMC das durações dos investimentos atavés do método que é explicado abaixo
    mmc = ObterMMC(investimentos)
    print("Mínimo múltiplo comum da duração dos investimentos: " + str(mmc))
    print("A viabilidade dos investimentos segue na ordem listada, bem como seus")
    print("valores presentes após " + str(mmc) + " anos:")
    ## Para cada investimento, calcula o VP após os anos
    for investimento in investimentos:
        ## Calcula o número de cíclos pelo qual o investimento irá passar
        numero_de_ciclos = mmc/investimento.duracao
        ## Obtém o VP do investimento após todos os ciclos
        VP = investimento.CalcularValorPresenteNCiclos(numero_de_ciclos, juros)
    ## Cria uma cópia da lista de investimentos, mas dessa vez, ordenada de acordo com o VP de cada investimento
    investimentos_ordenados = sorted(investimentos, key=lambda x: x.VP, reverse=True)
    ## Finalmente, imprime a lista ordenada, com os nomes e VPs de cada investimento
    for investimento in investimentos_ordenados:
        print(investimento.nome + " após " + str(mmc) + " anos, tem VP = " + str(format(investimento.VP, '.3f')))

print("\n\n\n")

## Método que cria uma instância de um investimento baseado nos valores dados pelo usuário
def InstanciarInvestimento():
    nome = raw_input("Qual é o nome do investimento? ")
    if nome == '':
        return None
    investimento_inicial = raw_input("Qual é o valor inicial do investimento? ")
    investimento_inicial = -float(investimento_inicial)
    ano = 0
    fluxo_de_caixa = []
    while True:
        ano = ano + 1
        fluxo = raw_input("Qual é o fluxo de caixa para o ano " + str(ano) + "? ")
        if fluxo == '':
            break
        else:
            fluxo = float(fluxo)
            fluxo_de_caixa.append(fluxo)
    return Investimento(nome, investimento_inicial, fluxo_de_caixa)

## Método que salva investimento em um arquivo
def SalvarInvestimento(investimento):
    if not os.path.exists("Investimentos/"):
        os.makedirs("Investimentos/")
    save_file = open("Investimentos/" + investimento.nome + ".inv", 'w')
    pickle.dump(investimento, save_file)
    save_file.close()

## Método que carrega investimento de um arquivo
def CarregarInvestimento(nome_do_investimento):
    load_file = open("Investimentos/" + nome_do_investimento + ".inv", 'r')
    investimento = pickle.load(load_file)
    load_file.close()
    return investimento

## Método que exibe todos os investimentos dentro da pasta de investimentos
def MostrarInvestimentos():
    investimentos = glob.glob("Investimentos/*.inv")
    
    for i in range(0,len(investimentos)):
        investimentos[i] = investimentos[i].replace(".inv", "")
        investimentos[i] = investimentos[i].replace("Investimentos\\", "")
        print(str(i+1) + " - " + investimentos[i])
    return investimentos

## Método que permite usuário visualizar um investimento dentro aqueles de uma lista
def VisualizarInvestimento(investimentos):
    opcao = raw_input("Escolha o investimento que deseja visualizar de acordo com seu número ou pelo seu nome: \n")
    print("\n\n\n")
    try:
        if int(opcao) <= len(investimentos):
            nome_do_investimento = investimentos[int(opcao)-1]
        else:
            print("Opção inválida")
            print("Digite o número de um dos investimentos ou o nome dele")
            return
    except:
        nome_do_investimento = opcao
    try:
        investimento = CarregarInvestimento(nome_do_investimento)
        investimento.MostrarInformacoes()
        print("\n\n\n")
    except:
        print("Investimento inválido")
        print("\n\n\n")
        return

## Métodos obtidos na internet
## Máximo divisor comum entre dois números
def gcd(a, b):
    """Return greatest common divisor using Euclid's Algorithm."""
    while b:      
        a, b = b, a % b
    return a

## Mínimo múltiplo comum entre dois números
def lcm(a, b):
    """Return lowest common multiple."""
    return a * b // gcd(a, b)

## Mínimo múltiplo comum entre mais de dois números
def lcmm(*args):
    """Return lcm of args."""   
    return reduce(lcm, args)

## Fim dos métodos obtidos na internet

## Encontra MMC das durações de todos os investimentos de uma lista
## baseado nos métodos obtidos na internet, logo acima
def ObterMMC(investimentos):
    duracoes = []
    for investimento in investimentos:
        duracoes.append(investimento.duracao)
    return (lcmm(*duracoes))

## Método de Menu
def Menu():
    print("Bem vindo ao comparador de investimento")
    while True:
        print("Para cadastrar um investimento, digite 1")
        print("Para visualizar a lista de investimentos registrados, digite 2")
        print("Para comparar os investimentos salvos, digite 3")
        print("Para sair, digite 0")
        opcao = raw_input("O que deseja fazer?\n")
        print("\n\n\n")
        
        if opcao == str(1):
            investimento = InstanciarInvestimento()
            SalvarInvestimento(investimento)

elif opcao == str(2):
            investimentos = MostrarInvestimentos()
            VisualizarInvestimento(investimentos)

elif opcao == str(3):
            CompararInvestimentos()

elif opcao == str(0):
            break

Menu()

Python Fiddle

Python Cloud IDE