Python e finanças – potencialize suas planilhas

Sumário executivo

Para profissões que há muito dependem de vasculhar planilhas, o Python é especialmente valioso. O Citigroup, um banco americano, introduziu um curso intensivo de Python para seus analistas estagiários. - O economista

Os profissionais de finanças há muito tempo têm acesso ao VBA (Visual Basic for Applications) no Excel para criar funcionalidades personalizadas e automatizar fluxos de trabalho. Com o surgimento nos últimos anos do Planilhas Google como um concorrente sério no espaço de planilhas, o Google Apps Script agora oferece uma opção adicional.

No entanto, gostaria de chamar a atenção para uma terceira opção, a linguagem de programação Python, que se tornou tremendamente popular em vários campos.

Neste artigo, fornecerei alguns exemplos do que você pode realizar com o Python, começando com uma visão geral da linguagem em si e por que ela se tornou tão popular em uma variedade tão ampla de campos, desde desenvolvimento web, aprendizado de máquina, finanças, ciência e educação, só para citar alguns. A segunda metade consistirá em um tutorial passo a passo.

O objetivo de escrever isso é ajudá-lo a decidir se o Python parece intrigante o suficiente para você considerar adicioná-lo à sua caixa de ferramentas financeiras. Se você der o salto, existem muitos aplicativos, cursos, vídeos, artigos, livros e postagens de blog disponíveis para aprender o idioma. No final do artigo, listei alguns recursos que me ajudaram ao longo do caminho.

Casos de uso: exemplos do que usei para o Python

Minha introdução à programação foi aprender BASIC em um Oric 1 em meados da década de 1980. Naquela época, BASIC era a linguagem mais comum para iniciantes. Outras linguagens com as quais me envolvi no final dos anos 80 até meados dos anos 90 foram Pascal e C, mas nunca as usei em nenhuma capacidade profissional e não esperava precisar ou usar habilidades de programação. Que eu saiba na época, no final dos anos 90, finanças e programação eram áreas muito diferentes, quando optei por embarcar em uma carreira em finanças.

Avanço rápido para 2012, e eu estava procurando retomar a programação como um hobby, então comecei a pesquisar as linguagens disponíveis na época. Acontece que muita coisa aconteceu e, quando me deparei com o Python, fiquei viciado, por muitas das razões que descreverei na próxima seção. Desde então, tenho usado Python para uma ampla gama de tarefas, desde pequenos scripts até projetos maiores, tanto pessoal quanto profissionalmente. Muitos, mas não todos, envolvem planilhas, a bancada de trabalho de muitos profissionais de finanças.

Aqui estão alguns exemplos de como as planilhas e o Python podem funcionar juntos:

1. Acompanhamento de centenas de atividades ao longo do tempo em uma configuração de PMO de integração de fusões e aquisições

Trabalho com todos os aspectos de transações de M&A, não apenas a execução, mas também a integração. Em um caso recente, a equipe do PMO optou por uma abordagem híbrida de programa e gerenciamento de projetos, usando planejamento em cascata e gráficos de Gantt para planos de alto nível para cada um dos doze fluxos de trabalho de integração, além de um quadro Kanban para rastrear as centenas de atividades a qualquer momento, no primeiro plano de 100 dias e além. A ferramenta Kanban escolhida, MeisterTask, possui uma série de recursos estatísticos e de relatórios, mas nossas necessidades foram além disso em termos de análise e apresentação, o que exigia uma solução personalizada. Este é o fluxo de trabalho que automatizei usando Python:

1. Salve o status de todo o quadro semanalmente como um arquivo CSV.
2. Leia todos os arquivos CSV históricos em um Pandas DataFrame.
3. Classifique, filtre, agrupe e manipule os dados em formatos acordados de como queremos acompanhar o progresso (pelo status da atividade, fluxo de trabalho etc.).
4. Grave a saída em um arquivo do Excel com os dados de cada análise em sua própria planilha, formatada de forma que possa ser simplesmente copiada e colada em gráficos do think-cell.
5. Crie tabelas e gráficos para o pacote de relatórios para a reunião mensal do comitê de direção.

Desenvolver o script exigiu um investimento inicial de algumas horas, mas agora, atualizar o pacote de relatórios para reuniões do comitê de direção ou análise ad hoc leva apenas alguns minutos. Literalmente, cerca de 30 segundos para ir para a pasta correta e executar o script com um comando de uma linha e, em seguida, alguns minutos para copiar e colar a saída no conjunto de slides. Com cerca de 500 atividades (cartões) em doze fluxos de trabalho já com cerca de um mês de execução, acompanhamento semanal de como elas se movem, dentro de um cronograma de dois anos, você rapidamente se vê lidando com milhares e, eventualmente, dezenas de milhares de pontos de dados em dezenas de arquivos. Sem automação, estamos falando de algumas tarefas muito tediosas aqui.

A troca de “valor do dinheiro no tempo” entre apenas continuar com as coisas ou adicionar mais carga de trabalho inicial configurando a automação é um tema comum em finanças. Tomei uma decisão semelhante na primeira etapa deste processo, exportando os dados como arquivos CSV. O MeisterTask, como muitos aplicativos da Web modernos, tem uma API, que pode ser conectada ao seu aplicativo Python, mas o tempo gasto na configuração superaria em muito a economia de tempo para nosso caso de uso aqui.

Então, como você vê, muitas vezes a solução ideal é automatizar certas etapas de um fluxo de trabalho e manter outras manuais.

2. Analisando estatísticas de preços de imóveis usando Web Scraping, API do Google Maps e Excel

Outro exemplo é algo que fiz por interesse pessoal, mas quero destacá-lo porque contém alguns outros elementos interessantes do utilitário do Python:

1. Raspe dados de listagens de imóveis, incluindo endereço, tamanho, número de quartos, preço pedido e outros recursos, para uma determinada área; algumas centenas a talvez mil linhas no total.
2. Salve em uma estrutura de dados Python.
3. Conecte-se à API do Google Maps e, para cada anúncio, recupere a distância entre a propriedade e os principais pontos de referência, como o mar, o centro da cidade, a estação de trem mais próxima, o aeroporto mais próximo etc.
4. Exporte os dados para um arquivo Excel.
5. Use a funcionalidade padrão do Excel para executar regressões, calcular estatísticas e criar gráficos em métricas padrão, como preço por metro quadrado e distância até pontos de referência.

Os resultados aqui podem ser combinados com suas próprias ponderações pessoais em termos de preferências e limitações financeiras ao procurar imóveis.

Estes são apenas dois exemplos, focados em automatizar o trabalho relacionado a planilhas e adicionar recursos, mas as oportunidades com o Python são quase infinitas. Na próxima seção, descreverei as razões pelas quais ele se tornou tão popular, antes de passar para um tutorial de simulação de Monte Carlo passo a passo em Python.

Por que o Python é uma ótima opção para profissionais de finanças

A linguagem de programação Python existe desde 1990, mas não foi até os últimos anos que sua popularidade explodiu.

Existem várias razões para isso, vamos olhar cada uma por sua vez.

1. Python é uma linguagem de programação de alto nível

Uma linguagem de programação de alto nível é aquela que abstrai muitos dos detalhes do funcionamento interno do computador. Um bom exemplo é o gerenciamento de memória. As linguagens de programação de nível inferior exigem uma compreensão detalhada das complexidades de como a memória do computador é disposta, alocada e liberada, além do tempo gasto e das linhas de código necessárias para lidar com as tarefas. O Python abstrai e lida com muitos desses detalhes automaticamente, deixando você se concentrar no que deseja realizar.

2. É Conciso

Como o Python é uma linguagem de programação de alto nível, o código é mais conciso e quase totalmente focado na lógica de negócios do que você deseja alcançar, em vez de detalhes técnicos de implementação. As escolhas de design de linguagem contribuem para isso: como exemplo, o Python não requer o uso de chaves ou ponto e vírgula para delinear funções, loops e linhas como muitas outras linguagens fazem, o que o torna mais conciso e, como alguns argumentam, melhora legibilidade.

3. Fácil de aprender e entender

Uma observação que influenciou as escolhas de design de linguagem em Python é que os programas são lidos com mais frequência do que escritos. O Python se destaca aqui, pois seu código se parece muito com o inglês simples, especialmente se você nomear os diferentes componentes do seu script ou programa de maneira sensata.

4. Adequado para Desenvolvimento Rápido e Iterativo

A tentativa e o erro esclarecidos superam o planejamento de intelectos perfeitos. - David Kelley

Python é ideal para prototipagem e desenvolvimento rápido e iterativo (e, sim, tentativa e erro) porque ferramentas de interpretação interativa, como o shell Python, IPython e notebooks Jupyter estão na frente e no centro da cadeia de ferramentas do Python. Nesses ambientes interativos, você pode escrever e executar cada linha de código isoladamente e ver os resultados (ou uma mensagem de erro útil) imediatamente. Outras linguagens também têm isso, mas na maioria dos casos não no mesmo grau que o Python.

5. Pode ser usado tanto para prototipagem quanto para código de produção

Além de ser ótimo para prototipagem, o Python também é uma linguagem excelente e poderosa para grandes aplicações de produção. Algumas das maiores empresas de software do mundo fazem uso intenso do Python em uma variedade de aplicativos e casos de uso.

6. Vem com “Baterias Incluídas”: A Biblioteca Padrão Python

Tudo o que é necessário para operações básicas está embutido na linguagem, mas, além disso, a biblioteca padrão do Python possui ferramentas para trabalhar com arquivos, mídia, rede, informações de data e hora e muito mais. Isso permite que você realize uma ampla variedade de tarefas sem precisar procurar pacotes de terceiros.

7. Ótimas bibliotecas de terceiros para análise financeira

Para profissionais de finanças, Pandas com seus objetos DataFrame e Series e Numpy com seu ndarray são os cavalos de trabalho da análise financeira com Python. Combinado com matplotlib e outras bibliotecas de visualização, você tem ótimas ferramentas à sua disposição para auxiliar na produtividade.

8. Python é grátis!

Python é desenvolvido sob uma licença de código aberto, tornando-o gratuito também para uso comercial.

Tutorial passo a passo de como usar Python e finanças juntos

O que segue é um tutorial passo a passo mostrando como criar uma versão simplificada da simulação de Monte Carlo descrita em meu post anterior, mas usando Python em vez do plugin @RISK para Excel.

Os métodos de Monte Carlo contam com amostragem aleatória para obter resultados numéricos. Uma dessas aplicações é extrair amostras aleatórias de uma distribuição de probabilidade representando estados futuros incertos do mundo, onde variáveis ​​ou suposições podem assumir uma série de valores.

É útil fazer a simulação de Monte Carlo em um modelo simplificado de avaliação DCF em vez dos exemplos mais comuns que você vê mostrando avaliação de opções ou outros derivativos, pois para isso não precisamos de nenhuma matemática além do básico de cálculo das demonstrações financeiras e descontando fluxos de caixa, permitindo-nos focar nos conceitos e ferramentas do Python. Observe, porém, que este modelo básico de tutorial destina-se a ilustrar os conceitos-chave e não é útil como está para fins práticos. Também não vou tocar em nenhum dos aspectos mais acadêmicos das simulações de Monte Carlo.

O tutorial pressupõe que você esteja familiarizado com os blocos de construção básicos da programação, como variáveis ​​e funções. Caso contrário, pode ser útil reservar 10 minutos para verificar os conceitos-chave, por exemplo, nesta introdução.

O ponto de partida e o resultado desejado

Começo com o mesmo modelo de avaliação DCF muito simplificado usado no tutorial de simulação de Monte Carlo. Ele tem alguns itens de linha principais das três demonstrações financeiras e três células de entrada destacadas, que na versão Excel têm estimativas pontuais que agora queremos substituir por distribuições de probabilidade para começar a explorar possíveis intervalos de resultados.

Uma abordagem em duas etapas para desenvolver um script pequeno

Faça funcionar, faça certo, faça rápido - Kent Beck

A intenção deste tutorial é dar aos profissionais de finanças novatos em Python uma introdução não apenas à aparência de um programa útil, mas também ao processo iterativo que você pode usar para desenvolvê-lo. Tem, portanto, duas partes:

1. Primeiro, desenvolvo um protótipo funcional usando uma abordagem direta que acho fácil de seguir e não completamente diferente do processo que se poderia usar para iniciar este projeto se você começasse do zero.
2. Então, depois de ter desenvolvido o protótipo funcional, passo pelo processo de refatoração - alterando a estrutura do código sem alterar sua funcionalidade. Você pode querer ficar nessa parte - é uma solução mais elegante do que a primeira e, como bônus, é cerca de 75 vezes mais rápida em termos de tempo de execução.

1. Desenvolvendo um protótipo funcional

Configurando o Jupyter Notebook

O notebook Jupyter é uma ótima ferramenta para trabalhar com Python de forma interativa. É um interpretador Python interativo com células que podem conter código, texto Markdown, imagens ou outros dados. Para este tutorial usei a plataforma Python Quant, mas também posso recomendar o Colaboratory do Google, que é gratuito e roda na nuvem. Uma vez lá, basta selecionar “New Python 3 Notebook” no menu “File” e você está pronto para começar.

Feito isso, o próximo passo é importar os pacotes de terceiros que precisamos para manipulação de dados e visualizações e informar ao programa que queremos ver gráficos em linha em nosso notebook, em vez de em janelas separadas:

 import numpy as np import pandas as pd import matplotlib.pyplot as plt %matplotlib inline

Uma observação antes de começarmos a nomear nossas primeiras variáveis. Como já destaquei, a legibilidade é um dos pontos fortes do Python. O design de linguagem ajuda bastante a suportar isso, mas todos que escrevem código são responsáveis ​​por torná-lo legível e compreensível, não apenas para os outros, mas também para si mesmos. Como afirma a Lei de Eagleson: “Qualquer código seu que você não tenha olhado por seis ou mais meses poderia muito bem ter sido escrito por outra pessoa”.

Uma boa regra geral é nomear os componentes do seu programa de forma que você minimize a necessidade de comentários separados que expliquem o que seu programa faz.

Com isso em mente, vamos em frente.

Criando as Demonstrações Financeiras

Há muitas maneiras de trabalhar com dados de planilhas existentes em Python. Poderíamos, por exemplo, ler uma planilha em um DataFrame do Pandas com uma linha de código usando o comando read_excel . Se você deseja uma integração mais estreita e um link em tempo real entre sua planilha e o código Python, existem opções gratuitas e comerciais disponíveis para fornecer essa funcionalidade.

Como o modelo aqui é muito simples, e para focar nos conceitos do Python, vamos recriá-lo do zero em nosso script. Ao final da primeira parte, mostrarei como você pode exportar o que criamos para uma planilha.

Como primeiro passo para criar uma representação Python das demonstrações financeiras, precisaremos de uma estrutura de dados adequada. Há muitos para escolher, alguns embutidos em Python, outros de várias bibliotecas, ou podemos criar o nosso próprio. Por enquanto, vamos usar uma série da biblioteca Pandas para dar uma olhada em sua funcionalidade:

 years = ['2018A', '2019B', '2020P', '2021P', '2022P', '2023P'] sales = pd.Series(index=years) sales['2018A'] = 31.0 sales

Esta entrada e sua saída correspondente são mostradas abaixo:

Com as três primeiras linhas, criamos uma estrutura de dados com um índice composto por anos (cada um marcado para mostrar se é Real, Orçamentário ou Projetado), um valor inicial (em milhões de euros, como no modelo DCF original) e células vazias (NaN, “Not a Number”) para as projeções. A quarta linha imprime uma representação dos dados - em geral, digitar o nome de uma variável ou outros objetos no interpretador interativo geralmente fornecerá uma representação sensata disso.

Em seguida, declaramos uma variável para representar o crescimento anual de vendas projetado. Nesta fase, é uma estimativa pontual, a mesma figura do nosso modelo DCF original. Queremos primeiro usar essas mesmas entradas e confirmar que nossa versão do Python executa o mesmo e fornece o mesmo resultado que a versão do Excel, antes de substituir as estimativas pontuais por distribuições de probabilidade. Usando essa variável, criamos um loop que calcula as vendas em cada ano das projeções com base no ano anterior e na taxa de crescimento:

 growth_rate = 0.1 for year in range(1, 6): sales[year] = sales[year - 1] * (1 + growth_rate) sales

Agora temos vendas projetadas, em vez de NaN:

Usando a mesma abordagem, continuamos com as demonstrações financeiras, declarando as variáveis ​​conforme precisamos delas e realizando os cálculos necessários para eventualmente chegar ao fluxo de caixa livre. Assim que chegarmos lá, podemos verificar se o que temos corresponde ao que diz a versão Excel do modelo DCF.

 ebitda_margin = 0.14 depr_percent = 0.032 ebitda = sales * ebitda_margin depreciation = sales * depr_percent ebit = ebitda - depreciation nwc_percent = 0.24 nwc = sales * nwc_percent change_in_nwc = nwc.shift(1) - nwc capex_percent = depr_percent capex = -(sales * capex_percent) tax_rate = 0.25 tax_payment = -ebit * tax_rate tax_payment = tax_payment.apply(lambda x: min(x, 0)) free_cash_flow = ebit + depreciation + tax_payment + capex + change_in_nwc free_cash_flow

Isso nos dá os fluxos de caixa livres:

A linha acima que talvez precise de um comentário neste estágio é a segunda referência tax_payment . Aqui, aplicamos uma pequena função para garantir que em cenários em que o lucro antes dos impostos se torne negativo, não teremos um pagamento de imposto positivo. Isso mostra a eficácia com que você pode aplicar funções personalizadas a todas as células em uma série Pandas ou DataFrame. A função real aplicada é, obviamente, uma simplificação. Um modelo mais realista para um exercício de avaliação maior teria um modelo de imposto separado que calcula os impostos reais pagos com base em vários fatores específicos da empresa.

Executando a Avaliação DCF

Tendo chegado aos fluxos de caixa projetados, agora podemos calcular um valor terminal simples e descontar todos os fluxos de caixa de volta ao presente para obter o resultado do DCF. O código a seguir apresenta a indexação e o slicing, que nos permite acessar um ou mais elementos em uma estrutura de dados, como o objeto Pandas Series.

Acessamos os elementos escrevendo colchetes diretamente após o nome da estrutura. A indexação simples acessa os elementos por sua posição, começando com zero, o que significa que free_cash_flow[1] nos daria o segundo elemento. [-1] é uma abreviação para acessar o último elemento (o fluxo de caixa do último ano é usado para calcular o valor terminal), e usar dois pontos nos dá uma fatia, o que significa que [1:] nos dá todos os elementos, exceto o primeiro, já que não queremos incluir o ano histórico 2018A em nossa avaliação do DCF.

 cost_of_capital = 0.12 terminal_growth = 0.02 terminal_value = ((free_cash_flow[-1] * (1 + terminal_growth)) / (cost_of_capital - terminal_growth)) discount_factors = [(1 / (1 + cost_of_capital)) ** i for i in range (1,6)] dcf_value = (sum(free_cash_flow[1:] * discount_factors) + terminal_value * discount_factors[-1]) dcf_value 

Isso conclui a primeira parte do nosso protótipo - agora temos um modelo DCF funcional, embora muito rudimentar, em Python.

Exportando os dados

Antes de passar para a simulação real de Monte Carlo, este pode ser um bom momento para mencionar os recursos de exportação disponíveis no pacote Pandas. Se você tiver um objeto Pandas DataFrame, poderá gravá-lo em um arquivo do Excel com uma linha usando o método to_excel . Existe uma funcionalidade semelhante para exportar para mais de uma dúzia de outros formatos e destinos.

 output = pd.DataFrame([sales, ebit, free_cash_flow], index=['Sales', 'EBIT', 'Free Cash Flow']).round(1) output.to_excel('Python DCF Model Output.xlsx') output 

Criando distribuições de probabilidade para nossa simulação de Monte Carlo

Agora estamos prontos para enfrentar o próximo desafio: substituir algumas das entradas de estimativas pontuais por distribuições de probabilidade. Embora as etapas até este ponto possam ter parecido um pouco complicadas em comparação com a construção do mesmo modelo no Excel, as próximas linhas lhe darão um vislumbre de quão poderoso o Python pode ser.

Nosso primeiro passo é decidir quantas iterações queremos executar na simulação. Usar 1.000 como ponto de partida alcança um equilíbrio entre obter pontos de dados suficientes para obter gráficos de saída sensatos, versus terminar a simulação dentro de um prazo sensato. Em seguida, geramos as distribuições reais. Por uma questão de simplicidade, eu gerei três distribuições normais aqui, mas a biblioteca NumPy tem um grande número de distribuições para escolher, e há outros lugares para procurar também, incluindo a biblioteca padrão Python. Depois de decidir qual distribuição usar, precisamos especificar os parâmetros necessários para descrever sua forma, como média e desvio padrão, e o número de resultados desejados.

 iterations = 1000 sales_growth_dist = np.random.normal(loc=0.1, scale=0.01, size=iterations) ebitda_margin_dist = np.random.normal(loc=0.14, scale=0.02, size=iterations) nwc_percent_dist = np.random.normal(loc=0.24, scale=0.01, size=iterations) plt.hist(sales_growth_dist, bins=20) plt.show() 

Aqui você pode argumentar que o EBITDA não deve ser uma variável aleatória separada independente das vendas, mas sim correlacionada com as vendas até certo ponto. Eu concordaria com isso e acrescentaria que deve ser impulsionado por uma sólida compreensão da dinâmica da estrutura de custos (custos variáveis, semivariáveis ​​e fixos) e os principais direcionadores de custos (alguns dos quais podem ter suas próprias distribuições de probabilidade, como, por exemplo, preços de commodities de insumos), mas deixo essas complexidades de lado aqui por uma questão de espaço e clareza.

Quanto menos dados você tiver para informar sua escolha de distribuição e parâmetros, mais terá que confiar no resultado de seus vários fluxos de trabalho de due diligence, combinados com a experiência, para formar uma visão consensual sobre vários cenários prováveis. Neste exemplo, com projeções de fluxo de caixa, haverá um grande componente subjetivo, o que significa que a visualização das distribuições de probabilidade se torna importante. Aqui, podemos obter uma visualização básica, mostrando a distribuição do crescimento das vendas, com apenas duas pequenas linhas de código. Dessa forma, podemos visualizar rapidamente qualquer distribuição para o globo ocular que melhor reflita a visão coletiva da equipe.

Agora temos todos os blocos de construção necessários para executar a simulação, mas eles não estão em um formato conveniente para executar a simulação. Aqui está o mesmo código com o qual trabalhamos até agora, mas todos reunidos em uma célula e reorganizados em uma função por conveniência:

 def run_mcs(): # Create probability distributions sales_growth_dist = np.random.normal(loc=0.1, scale=0.01, size=iterations) ebitda_margin_dist = np.random.normal(loc=0.14, scale=0.02, size=iterations) nwc_percent_dist = np.random.normal(loc=0.24, scale=0.01, size=iterations) # Calculate DCF value for each set of random inputs output_distribution = [] for i in range(iterations): for year in range(1, 6): sales[year] = sales[year - 1] * (1 + sales_growth_dist[0]) ebitda = sales * ebitda_margin_dist[i] depreciation = (sales * depr_percent) ebit = ebitda - depreciation nwc = sales * nwc_percent_dist[i] change_in_nwc = nwc.shift(1) - nwc capex = -(sales * capex_percent) tax_payment = -ebit * tax_rate tax_payment = tax_payment.apply(lambda x: min(x, 0)) free_cash_flow = ebit + depreciation + tax_payment + capex + change_in_nwc # DCF valuation terminal_value = (free_cash_flow[-1] * 1.02) / (cost_of_capital - 0.02) free_cash_flow[-1] += terminal_value discount_factors = [(1 / (1 + cost_of_capital)) ** i for i in range (1,6)] dcf_value = sum(free_cash_flow[1:] * discount_factors ) output_distribution.append(dcf_value) return output_distribution

Agora podemos executar toda a simulação e plotar a distribuição de saída, que será o valor do fluxo de caixa descontado dessa empresa em cada uma das 1.000 iterações, com o código a seguir. O comando %time não é um código Python, mas uma abreviação de notebook que mede o tempo para executar algo (você pode usar a função Python da biblioteca padrão). Depende do computador em que você o executa, mas esta versão precisa de 1-2 segundos para executar as 1.000 iterações e visualizar o resultado.

 %time plt.hist(run_mcs(), bins=20, color='r') plt.show() 

2. Refinando o protótipo

A suspeita à espreita de que algo poderia ser simplificado é a fonte mais rica de desafios recompensadores do mundo. - Edsger Dijkstra

A refatoração refere-se ao processo de reescrever o código existente para melhorar sua estrutura sem alterar sua funcionalidade, e pode ser um dos elementos mais divertidos e recompensadores da codificação. Pode haver várias razões para fazer isso. Pode ser para:

1. Organize as diferentes partes de uma forma mais sensata.
2. Renomeie variáveis ​​e funções para tornar seu propósito e funcionamento mais claros.
3. Permita e prepare-se para recursos futuros.
4. Melhore a velocidade de execução, o consumo de memória ou a utilização de outros recursos.

Para mostrar como pode ser uma etapa desse processo, limpei o protótipo que acabamos de percorrer coletando todas as variáveis ​​iniciais em um só lugar, em vez de espalhadas como no script do protótipo, e otimizei sua velocidade de execução por meio de um processo chamado vetorização .

O uso de arrays NumPy permite que você expresse muitos tipos de tarefas de processamento de dados como expressões de array concisas que, de outra forma, podem exigir loops de gravação. Essa prática de substituir loops explícitos por expressões de matriz é comumente chamada de vetorização. Wes McKinney

Agora parece mais limpo e fácil de entender:

 # Key inputs from DCF model years = 5 starting_sales = 31.0 capex_percent = depr_percent = 0.032 sales_growth = 0.1 ebitda_margin = 0.14 nwc_percent = 0.24 tax_rate = 0.25 # DCF assumptions r = 0.12 g = 0.02 # For MCS model iterations = 1000 sales_std_dev = 0.01 ebitda_std_dev = 0.02 nwc_std_dev = 0.01

 def run_mcs(): # Generate probability distributions sales_growth_dist = np.random.normal(loc=sales_growth, scale=sales_std_dev, size=(years, iterations)) ebitda_margin_dist = np.random.normal(loc=ebitda_margin, scale=ebitda_std_dev, size=(years, iterations)) nwc_percent_dist = np.random.normal(loc=nwc_percent, scale=nwc_std_dev, size=(years, iterations)) # Calculate free cash flow sales_growth_dist += 1 for i in range(1, len(sales_growth_dist)): sales_growth_dist[i] *= sales_growth_dist[i-1] sales = sales_growth_dist * starting_sales ebitda = sales * ebitda_margin_dist ebit = ebitda - (sales * depr_percent) tax = -(ebit * tax_rate) np.clip(tax, a_min=None, a_max=0) nwc = nwc_percent_dist * sales starting_nwc = starting_sales * nwc_percent prev_year_nwc = np.roll(nwc, 1, axis=0) prev_year_nwc[0] = starting_nwc delta_nwc = prev_year_nwc - nwc capex = -(sales * capex_percent) free_cash_flow = ebitda + tax + delta_nwc + capex # Discount cash flows to get DCF value terminal_value = free_cash_flow[-1] * (1 + g) / (r - g) discount_rates = [(1 / (1 + r)) ** i for i in range (1,6)] dcf_value = sum((free_cash_flow.T * discount_rates).T) dcf_value += terminal_value * discount_rates[-1] return dcf_value

A principal diferença que você notará entre esta versão e a anterior é a ausência do loop for i in range(iterations) . Usando a operação de array do NumPy, esta versão é executada em 18 milissegundos em comparação com os 1,35 segundos da versão protótipo - aproximadamente 75x mais rápido.

 %time plt.hist(run_mcs(), bins=20, density=True, color="r") plt.show() 

Tenho certeza de que é possível otimizar ainda mais, pois montei o protótipo e a versão refinada em pouco tempo apenas para o propósito deste tutorial.

Levando mais longe

Este tutorial mostrou alguns dos recursos poderosos do Python e, se você desenvolver isso ainda mais, as oportunidades são quase infinitas. Você poderia por exemplo:

• Raspe ou baixe estatísticas relevantes de empresas ou setores de páginas da web ou outras fontes de dados, para ajudar a informar sua escolha de suposições e distribuições de probabilidade.
• Use Python em aplicativos financeiros quantitativos, como em um algoritmo de negociação automatizado com base em fatores fundamentais e/ou macroeconômicos.
• Crie recursos de exportação que gerem saída em formato de planilha e/ou apresentação, para serem usados ​​como parte de seu processo interno de revisão e aprovação de transações ou para apresentações externas.

Eu nem mencionei o que você também poderia fazer com os vários aplicativos da Web, ciência de dados e aprendizado de máquina que contribuíram para o sucesso do Python.

Em resumo: uma linguagem útil para sua caixa de ferramentas financeiras

Este artigo deu uma introdução à linguagem de programação Python, listou algumas das razões pelas quais ela se tornou tão popular em finanças e mostrou como construir um pequeno script Python. Em um tutorial passo a passo, expliquei como o Python pode ser usado para prototipagem iterativa, análise financeira interativa e código de aplicativo para modelos de avaliação, programas de negociação algorítmica e muito mais.

Para mim, no final das contas, o recurso matador da tecnologia Python é que é simplesmente divertido trabalhar com ela! Se você gosta de resolver problemas, construir coisas e tornar os fluxos de trabalho mais eficientes, recomendo que experimente. Eu adoraria ouvir o que você fez com ele ou gostaria de fazer com ele.

Recursos recomendados para profissionais de finanças aprenderem Python

• Livros O'Reilly. Posso recomendar especialmente:
  • Python for Finance by Yves Hilpisch
  • Learning Python by Mark Lutz
  • Fluent Python by Luciano Ramalho
• The Python Quants
• PyCon talks on YouTube
• Udemy