Python para negociação algorítmica - página 24

[MetaQuotes]

Como calcular a volatilidade do portfólio de investimentos em ações com Python, NumPy e Pandas

Como calcular a volatilidade do portfólio de investimentos em ações com Python, NumPy e Pandas

Neste vídeo, o apresentador demonstra como calcular a volatilidade de uma carteira de investimentos usando Python e inclui as equações matemáticas por trás disso. O foco está em uma carteira de dois títulos, pois é facilmente calculada em uma calculadora portátil. No entanto, o apresentador menciona que para carteiras com mais de três títulos, utiliza-se a multiplicação de matrizes para calcular a volatilidade. O apresentador utiliza a biblioteca NumPy e outras bibliotecas de suporte para realizar os cálculos.

O vídeo começa com a configuração do ambiente Python e a importação dos módulos necessários. O apresentador então define as variáveis que serão utilizadas ao longo do processo.

Para obter dados em tempo real para o portfólio, o apresentador menciona o uso de uma API e demonstra especificamente o uso de dados históricos de final de dia. Eles explicam que uma chave de API é necessária para acessar os dados e fornecem instruções sobre como registrar e obter a chave. A data de início dos dados está definida para cerca de um ano atrás. O apresentador configura o portfólio, atribui pesos iguais a cada título e cria uma lista vazia para armazenar os dados baixados.

Usando um loop for, o apresentador faz chamadas de API para cada símbolo no portfólio e recupera os dados. Eles demonstram como construir a chamada de API obtendo a URL do endpoint no site do provedor de dados e fazendo as modificações necessárias. Os dados são recuperados como uma string JSON, que é convertida em um DataFrame pandas para processamento posterior. Os preços de fechamento são extraídos do DataFrame e adicionados à lista de dados.

Depois de concluir o loop for, o apresentador converte a lista de dados em um DataFrame, transpõe-o, renomeia as colunas com os nomes dos símbolos e altera o índice para datas. Eles então exibem o DataFrame resultante contendo os preços de fechamento de cada título.

Para calcular a volatilidade, o apresentador explica que é preciso calcular taxas de retorno instantâneas. Eles criam um novo DataFrame usando a função de logaritmo do NumPy nos preços de fechamento e calculam as diferenças entre valores consecutivos. O DataFrame resultante representa as taxas instantâneas de retorno para cada título. O apresentador remove a primeira linha do DataFrame para manipular quaisquer valores NaN e demonstra o cálculo da variação para cada título.

Para calcular a volatilidade de cada título, o apresentador usa a raiz quadrada da variação. Eles exibem as volatilidades resultantes como porcentagens.

Para a volatilidade da carteira, o apresentador explica que ela pode ser calculada como a média ponderada das volatilidades de cada título. Como os títulos no exemplo são igualmente ponderados, o apresentador precisa apenas da média das volatilidades. Eles o formatam como uma porcentagem.

Em seguida, o apresentador introduz o conceito de matriz de covariância e demonstra como calculá-la usando o DataFrame de retornos. Eles ajustam a covariância diária para uma covariância anual e exibem a matriz de covariância resultante.

Por fim, o apresentador calcula a volatilidade do portfólio usando a multiplicação de matrizes. Eles multiplicam os pesos pela matriz de covariância e tiram a raiz quadrada do resultado. A volatilidade da carteira é exibida como uma porcentagem, representando o desvio padrão.

Concluindo, o vídeo fornece uma demonstração passo a passo de como calcular a volatilidade do portfólio usando Python. O apresentador explica os cálculos necessários, apresenta bibliotecas relevantes como NumPy e enfatiza os benefícios da diversificação na redução da volatilidade do portfólio.

[MetaQuotes]

Introdução ao Steamlit para Python - Crie um aplicativo da Web funcional em minutos

Introdução ao Steamlit para Python - Crie um aplicativo da Web funcional em minutos

Neste vídeo, demonstrarei como usar o Streamlit for Python para criar um aplicativo da web. O Streamlit é uma interface do usuário baseada na Web de uso gratuito e que permite criar e compartilhar aplicativos de alta qualidade sem qualquer experiência de desenvolvimento front-end. Estaremos construindo um aplicativo simples que nos permite baixar dados de preços de ações usando uma API e grafá-los. Vamos começar!

Primeiro, usarei o PyCharm como meu IDE, mas você pode usar qualquer IDE de sua escolha. Se você não estiver familiarizado com o PyCharm, forneci um link na descrição do vídeo para um vídeo "Introdução ao PyCharm". Fique à vontade para conferir se quiser saber mais.

Já configurei um novo projeto no PyCharm chamado "Streamlit Demo" e adicionei um arquivo Python. Como estamos começando com um novo ambiente virtual, precisamos instalar algumas dependências. Vamos precisar do Pandas, da biblioteca Requests e do Streamlit. Dependendo da configuração do seu PyCharm, você já pode ter o Pandas e o Requests instalados, mas com certeza precisará instalar o Streamlit. Além disso, usaremos a API "End of Day Historical Data" para nosso aplicativo, que permite chamadas de API gratuitas com um limite de cerca de 20 por dia. Se você precisar de mais do que isso, eles oferecem opções de assinatura em seu site.

Depois que o Streamlit estiver instalado, vamos dar uma olhada em seu aplicativo de exemplo. Vou abrir o terminal e executar o Streamlit chamando o Python na linha de comando e, em seguida, executando o comando Streamlit. Seu aplicativo de exemplo está em um arquivo chamado "hello". Após alguns segundos, o aplicativo será iniciado e você verá uma página da Web com um cabeçalho, algum texto e hiperlinks. No lado esquerdo, existem várias demonstrações que você pode explorar. O bom de suas demonstrações é que elas fornecem o código usado para gerar a saída. Por exemplo, há um demo com um gráfico e, abaixo dele, você pode ver o código usado para gerar esse gráfico. O Streamlit cuida da formatação e colocação do conteúdo na página da web, então você só precisa se concentrar em escrever o código para produzir a saída desejada.

Quando estiver satisfeito com seu aplicativo, você pode solicitar permissão do Streamlit para publicá-lo ao vivo. Eles ainda oferecem publicação gratuita, mas você precisa contatá-los para configurá-lo. Posteriormente, você pode enviar seus arquivos para o GitHub e compartilhar seu aplicativo ao vivo em segundos.

Agora vamos passar para a criação de nosso próprio aplicativo. Demonstrarei alguns recursos do Streamlit antes de começarmos a escrever nosso código de aplicativo. Streamlit fornece vários elementos que você pode usar, como botões, seletores de cores, barras laterais, caixas de texto e seletores de data. O elemento mais comumente usado é a função "escrever", que permite exibir texto na página da web. Você também pode usar a sintaxe markdown dentro da função "write" para formatar o texto. Além disso, se você deseja exibir texto de formato livre, basta usar uma docstring e o Streamlit o renderizará como markdown.

Vamos testar alguns desses recursos escrevendo um aplicativo básico. Vou definir algumas dependências e depois mostrar como usar os elementos Streamlit. Começaremos com a função "st" e exploraremos seus diferentes recursos. Por exemplo, podemos usar "st.button" para exibir um botão, "st.color_picker" para um seletor de cores e "st.sidebar" para criar uma barra lateral. A função "escrever" também é bastante útil para exibir texto e você pode usar a sintaxe de marcação dentro dela. Demonstrarei esses recursos comuns, mas lembre-se de que o Streamlit oferece muito mais opções.

Para executar o aplicativo, irei parar o servidor Streamlit atual e iniciá-lo novamente executando o comando Python com o nome.

Aqui está um exemplo de um aplicativo Streamlit simples que permite baixar e representar graficamente os dados do preço das ações:

import streamlit as st
import pandas as pd
import requests

# Set the title and page layout
st.title( "Stock Price Data" )
st.sidebar.header( "Settings" )

# Create input fields in the sidebar
symbol = st.sidebar.text_input( "Enter a stock symbol (e.g., AAPL)" , value= "AAPL" )
start_date = st.sidebar.text_input( "Enter the start date (YYYY-MM-DD)" , value= "2022-01-01" )
end_date = st.sidebar.text_input( "Enter the end date (YYYY-MM-DD)" , value= "2022-12-31" )

# Create a button to trigger the data retrieval
if st.sidebar.button( "Get Data" ):
     # Make an API request to retrieve the stock price data
    url = f " https://api.example.com/stock/ {symbol}/history?start_date={start_date}&end_date={end_date}"
    response = requests.get(url)
    
     # Check if the API request was successful
     if response.status_code == 200 :
        data = response.json()
        df = pd.DataFrame(data)
        
         # Display the downloaded data
        st.write(df)
        
         # Create a line chart of the stock prices
        st.line_chart(df[ "close" ])
     else :
        st.write( "Error retrieving data from the API" )

# Add some additional information to the sidebar
st.sidebar.info( "This is a simple app to download and graph stock price data." )
st.sidebar.info( "Enter the stock symbol and date range, then click 'Get Data' to retrieve the data." )

Neste exemplo, primeiro importamos as bibliotecas necessárias: Streamlit, Pandas e Requests. Em seguida, definimos o título e o layout da página usando as funções st.title() e st.sidebar.header().

Em seguida, criamos campos de entrada na barra lateral usando a função st.sidebar.text_input(). Os usuários podem inserir um símbolo de ação, data inicial e data final nesses campos.

Em seguida, criamos um botão usando a função st.sidebar.button(). Quando o botão é clicado, ele aciona o processo de recuperação de dados. Construímos a URL de solicitação de API usando o símbolo inserido, a data de início e a data de término. Fazemos uma solicitação GET para a API usando a função request.get().

Se a solicitação da API for bem-sucedida (código de status 200), recuperamos os dados da resposta e criamos um Pandas DataFrame. Exibimos os dados baixados usando a função st.write() e, em seguida, criamos um gráfico de linhas dos preços das ações usando a função st.line_chart().

Se a solicitação da API falhar, exibimos uma mensagem de erro usando a função st.write().

Por fim, adicionamos algumas informações adicionais à barra lateral usando a função st.sidebar.info().

Para executar este aplicativo, você pode salvá-lo em um arquivo Python (por exemplo, stock_app.py) e executá-lo usando o comando streamlit run stock_app.py em seu terminal.

Este é apenas um exemplo básico e você pode personalizá-lo ainda mais com base em suas necessidades. O Streamlit fornece muito mais recursos para criar aplicativos da Web interativos, incluindo menus suspensos, caixas de seleção, controles deslizantes e muito mais. Você pode explorar a documentação do Streamlit ( https://docs.streamlit.io/ ) para obter mais informações e exemplos.

[MetaQuotes]

Use a API de dados históricos do fim do dia (EOD) para encontrar a hora da máxima/mínima diária

Use a API de dados históricos do fim do dia (EOD) para encontrar a hora da máxima/mínima diária

Neste vídeo, vamos explorar a API de dados históricos do fim do dia, que nos permite extrair os preços diários máximos e mínimos de negociação de uma ação. Essa API faz parte de um modelo freemium para dados financeiros, oferecendo 20 chamadas de API gratuitas por dia. A vantagem dessa API é que ela fornece acesso a dados de mais de 70 bolsas globais. Você pode encontrar o link para o site deles e preços especiais na descrição do vídeo.

Para começar, precisamos configurar nosso ambiente. Usaremos o módulo datetime para manipular datas, a biblioteca auxiliar para acessar dados históricos, pandas para manipulação e filtragem de dados e solicitações para fazer chamadas de API. Em seguida, precisamos obter nossa chave de API, que pode ser armazenada em um arquivo ou diretamente no notebook para simplificar.

Também definiremos a data de início de nossos dados, geralmente voltando cerca de 10 dias. A API tem limitações diferentes com base no tipo de dados, com dados minuto a minuto limitados a 120 dias e dados de intervalo de cinco minutos limitados a 600 dias. A API indexa os dados usando o carimbo de data/hora do Unix, que representa o número de segundos decorridos desde 1º de janeiro de 1970. Convertemos a data de início desejada em um carimbo de data/hora do Unix para a solicitação da API.

Com a configuração necessária concluída, podemos criar uma instância do objeto "End of Day Historical Data" usando nossa chave de API. Este objeto nos permite recuperar os dados que precisamos. A biblioteca auxiliar fornece vários terminais que podem ser explorados para diferentes tipos de dados. Neste exemplo, vamos nos concentrar em recuperar os preços intradiários da Tesla usando intervalos de um minuto, a partir da data de início especificada.

Para visualizar os dados, podemos agrupar a chamada da API em um construtor para um Pandas DataFrame. Isso facilita o trabalho e a visualização dos dados. Exibimos as primeiras linhas do DataFrame para verificar os dados recuperados, incluindo o timestamp Unix, data e hora.

Se você preferir não usar a biblioteca auxiliar, o vídeo oferece uma abordagem alternativa usando a biblioteca de solicitações para acessar diretamente o endpoint da API e recuperar os dados JSON.

Em seguida, realizamos alguma limpeza de dados. Substituímos o índice baseado em número inteiro pela data e hora dos dados. Adicionamos colunas separadas para hora e data e removemos colunas desnecessárias, como deslocamento GMT e data e hora originais. O DataFrame resultante mostra a estrutura revisada com as colunas adicionadas.

Para focar no horário regular de negociação, criamos uma cópia dos dados originais. Como o índice é um objeto datetime, podemos usar o método between_time para filtrar os horários desejados. Como o vídeo menciona, o fuso horário para esses dados é GMT-5, então ajustamos os horários de acordo. Também convertemos os horários para o horário do leste (ET) para facilitar a interpretação.

Para filtrar apenas a hora da coluna datetime, realizamos algumas etapas adicionais. Como já realizamos um cálculo, precisamos formatar os dados novamente antes de aplicar o método datetime para extrair a hora. O DataFrame resultante exibe os horários ajustados na cidade de Nova York.

Por fim, abordamos a questão original de quando ocorrem as máximas e mínimas durante o dia de negociação. Primeiro, recuperamos a alta e a baixa gerais de cada dia usando a função groupby e os métodos min e max. Para determinar o tempo específico desses altos e baixos, localizamos o índice dos valores mínimo e máximo dentro do DataFrame, respectivamente. Isso fornece informações sobre o momento desses pontos de preço, permitindo-nos observar quaisquer padrões ou tendências.

No geral, este vídeo fornece um guia passo a passo para usar a API de dados históricos do fim do dia, recuperar dados de preços de ações e analisar o momento dos preços de negociação altos e baixos.

[MetaQuotes]

Como testar algoritmos de negociação e métricas de portfólio com Python e QuantStats

Como testar algoritmos de negociação e métricas de portfólio com Python e QuantStats

Hoje, vou orientá-lo por uma visão geral abrangente das estatísticas Quant, uma extensa biblioteca de métricas financeiras criada como uma ferramenta de criação de perfil de portfólio. Com estatísticas Quant, você pode gerar relatórios detalhados sem esforço usando apenas uma linha simples. Essa ferramenta permite que você meça efetivamente o desempenho do portfólio e teste os algoritmos de negociação.

O Quant stats depende de bibliotecas de ciência de dados conhecidas com as quais você já deve estar familiarizado e usar. Para esta demonstração, estou trabalhando no PyCharm e iniciei um novo projeto. Se você estiver acompanhando, certifique-se de ter as dependências necessárias instaladas. Estou usando uma versão um pouco mais antiga do Pandas porque as estatísticas do Quant não são atualizadas há cerca de seis meses e pode haver alguns problemas de compatibilidade com as versões mais recentes do Pandas.

Para garantir que você tenha as dependências necessárias, você pode adicioná-las a um arquivo requirements.txt e instalá-las usando o Pip. Além disso, o Quant stats consiste em três módulos: estatísticas, gráficos e relatórios. Devido à extensa funcionalidade, não poderei cobrir tudo neste único vídeo. No entanto, fornecerei uma visão geral e orientarei você sobre como começar. Você pode então explorar mais com base em suas necessidades e interesses específicos.

Antes de mergulharmos nos detalhes, vamos ouvir nosso patrocinador por um momento. Se você estiver interessado em aprender como criar algoritmos de negociação com Python, permita que a Looming Wealth o ajude com seu curso de negociação algorítmica. Neste curso, você aprenderá a criar bots que negociam automaticamente em seu nome, implementam e utilizam métricas técnicas e financeiras e usam aprendizado de máquina para desenvolver algoritmos de negociação exclusivos. Você pode aprender no seu próprio ritmo ou participar de aulas ao vivo para uma experiência de aprendizado colaborativo. Siga o link abaixo para saber mais sobre a Looming Wealth e obter um desconto de 15% em qualquer um de seus cursos de negociação.

Agora, vamos voltar às estatísticas Quant. Em um novo arquivo em branco, comece importando a biblioteca de estatísticas Quant. Em seguida, defina um símbolo de ação para analisar. Para este exemplo, usarei o S&P 500 ETF (SPY). Usaremos estatísticas Quant para examinar seu desempenho nos últimos três anos.

Para baixar os dados de retornos, utilizaremos os utilitários de estatísticas Quant, que dependem dos dados do Yahoo Finance. Você pode usar qualquer fonte de dados de sua preferência; não há mágica aqui. Vamos imprimir os retornos para ver o que obtemos. A saída será uma série Pandas com retornos diários abrangendo o período de tempo especificado.

Assim que tivermos os dados de retorno, podemos calcular várias estatísticas usando estatísticas Quant. Existem inúmeras funções disponíveis, muito mais do que podemos cobrir neste vídeo. Você pode obter uma lista de estatísticas disponíveis imprimindo o atributo available_stats. Vamos exibir uma lista com as estatísticas disponíveis, excluindo as funções privadas.

Vou comentar um pouco da compreensão da lista para mantê-la concisa. Continuaremos a imprimir algumas estatísticas comuns para o S&P 500 nos últimos três anos. Vamos calcular o índice de Sharpe usando qs.stats.sharpe_ratio(). Além disso, encontraremos o melhor dia e mês chamando qs.stats.best_day() e qs.stats.best_month() respectivamente. Você pode modificar essas chamadas para agregar dados de forma diferente, se necessário.

Alternativamente, Quant stats fornece um wrapper para Pandas, permitindo que você faça chamadas de método diretamente no objeto do portfólio. Ao estender o Pandas, você pode usar one-liners para acessar várias estatísticas. Por exemplo, você pode chamar Quant stats.extend_pandas() e usar o objeto de portfólio para recuperar estatísticas como retorno bruto anual composto e redução máxima.

Além das estatísticas, o Quant stats também oferece a capacidade de criar portfólios.

Em seguida, vou calcular os sinais com base na estratégia de cruzamento de média móvel. Se a média móvel rápida estiver acima da média móvel lenta, é um sinal de compra. Caso contrário, é um sinal de venda. Vou adicionar esses sinais ao quadro de dados.

Depois disso, vou calcular as posições com base nos sinais. Se for um sinal de compra, definirei a posição como 1 (indicando uma posição longa) e se for um sinal de venda, definirei a posição como -1 (indicando uma posição curta). Todos os outros casos serão definidos como 0 (indicando nenhuma posição).

Agora que temos as posições, vou calcular os retornos da estratégia. Para isso, multiplicarei as posições pelos retornos diários do ativo. Isso nos dará os retornos diários da estratégia.

Em seguida, calcularei os retornos cumulativos da estratégia tomando o produto cumulativo dos retornos diários. Isso nos dará o crescimento da estratégia ao longo do tempo.

Finalmente, vou gerar o relatório usando a função quantstats.reports.html. Essa função pega os dados de retornos cumulativos e gera um relatório HTML com várias métricas e visualizações de desempenho. Vou salvar o relatório como um arquivo HTML.

Para visualizar o relatório automaticamente, abro o arquivo usando o navegador da web. E é isso para o código.

Agora, quando você executar este código com os parâmetros escolhidos, ele gerará a estratégia de cruzamento de média móvel, calculará as métricas de desempenho e gerará um relatório HTML com os resultados. Você pode personalizar os parâmetros da estratégia, como os períodos de média móvel ou a janela de tempo, para atender às suas necessidades.