Skip to content
TheChatArchiveThe Chat Archive
o1-preview-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

um código em python que mostre o bitcoin 5 minutos plotado pelo plotly.js obtendo dados…

  1. User

    um código em python que mostre o bitcoin 5 minutos plotado pelo plotly.js obtendo dados pelo metatrader 5, em candlestik, que reconheça movimentos de alta e baixa e durante esses movimentos calcule a possibilidade de pullback e as regiões do pullback, use o melhor conceito como parâmetro de pullback do preço.

  2. Assistant

    Claro, abaixo está um código em Python que:

    • Obtém dados de velas de 5 minutos do Bitcoin (BTCUSD) pelo MetaTrader 5.
    • Plota os dados em um gráfico de candlestick usando Plotly.
    • Reconhece movimentos de alta e baixa (tendências) usando a média móvel exponencial de 20 períodos (EMA20).
    • Durante esses movimentos, calcula a possibilidade de pullback e as regiões de pullback utilizando os níveis de retração de Fibonacci, que é um dos melhores conceitos utilizados como parâmetro para pullback de preço.

    Antes de executar o código, certifique-se de que:

    • O MetaTrader 5 esteja instalado e você esteja logado em uma conta que permita acesso ao símbolo BTCUSD.
    • O pacote MetaTrader5 esteja instalado (pip install MetaTrader5).
    • O pacote plotly esteja instalado (pip install plotly).
    import MetaTrader5 as mt5
    import pandas as pd
    import numpy as np
    import plotly.graph_objects as go
    from datetime import datetime, timedelta
    
    # Inicializa a conexão com o MetaTrader 5
    if not mt5.initialize():
        print("Falha ao inicializar")
        mt5.shutdown()
    
    # Seleciona o símbolo e o timeframe
    symbol = "BTCUSD"  # Verifique se este símbolo está disponível na sua plataforma MT5
    timeframe = mt5.TIMEFRAME_M5
    
    # Define o período de tempo para obter os dados
    # Obtém dados dos últimos 5 dias
    utc_from = datetime.now() - timedelta(days=5)
    utc_to = datetime.now()
    
    # Obtém os dados de taxas
    rates = mt5.copy_rates_range(symbol, timeframe, utc_from, utc_to)
    
    # Encerra a conexão com o MetaTrader 5
    mt5.shutdown()
    
    # Converte para DataFrame do pandas
    df = pd.DataFrame(rates)
    
    # Converte o tempo em segundos para o formato datetime
    df['time'] = pd.to_datetime(df['time'], unit='s')
    
    # Calcula a EMA de 20 períodos
    df['EMA20'] = df['close'].ewm(span=20, adjust=False).mean()
    
    # Calcula a inclinação da EMA20
    df['EMA20_slope'] = df['EMA20'].diff()
    
    # Determina a tendência (alta, baixa, neutra)
    conditions = [
        (df['close'] > df['EMA20']) & (df['EMA20_slope'] > 0),
        (df['close'] < df['EMA20']) & (df['EMA20_slope'] < 0)
    ]
    choices = ['uptrend', 'downtrend']
    df['trend'] = np.select(conditions, choices, default='neutral')
    
    # Calcula a distância percentual entre o preço de fechamento e a EMA20
    df['distance_pct'] = (df['close'] - df['EMA20']) / df['EMA20'] * 100
    
    # Define condição de possível pullback
    df['pullback_possible'] = np.where(
        ((df['trend'] == 'uptrend') & (df['distance_pct'] > 1)) |
        ((df['trend'] == 'downtrend') & (df['distance_pct'] < -1)),
        True, False)
    
    # Marca os pontos onde o pullback é possível
    df['pullback_marker'] = df['close'].where(df['pullback_possible'])
    
    # Identifica as mudanças de tendência
    df['trend_shift'] = df['trend'] != df['trend'].shift(1)
    trend_changes_indices = df[df['trend_shift']].index.tolist()
    # Adiciona o último índice para fechar o último segmento
    trend_changes_indices.append(df.index[-1])
    
    # Cria segmentos de tendência
    trend_segments = []
    for i in range(len(trend_changes_indices) - 1):
        start_idx = trend_changes_indices[i]
        end_idx = trend_changes_indices[i+1] - 1
        trend_type = df.loc[start_idx, 'trend']
        trend_segments.append((start_idx, end_idx, trend_type))
    
    # Função para calcular os níveis de Fibonacci
    def calculate_fib_levels(df_segment, trend_type):
        if trend_type == 'uptrend':
            max_price = df_segment['high'].max()
            min_price = df_segment['low'].min()
        elif trend_type == 'downtrend':
            max_price = df_segment['high'].max()
            min_price = df_segment['low'].min()
        else:
            return None  # Ignora tendências neutras
        diff = max_price - min_price
        levels = {
            '0%': max_price,
            '38.2%': max_price - 0.382 * diff,
            '50%': max_price - 0.5 * diff,
            '61.8%': max_price - 0.618 * diff,
            '100%': min_price
        }
        return levels
    
    # Obtém o último segmento de tendência
    last_trend_segment = trend_segments[-1]
    start_idx, end_idx, trend_type = last_trend_segment
    df_segment = df.loc[start_idx:end_idx]
    
    # Calcula os níveis de Fibonacci para o último segmento
    fib_levels = calculate_fib_levels(df_segment, trend_type)
    
    # Cria o gráfico
    fig = go.Figure(data=[go.Candlestick(x=df['time'],
                                         open=df['open'],
                                         high=df['high'],
                                         low=df['low'],
                                         close=df['close'],
                                         name='Candlesticks')])
    
    # Adiciona a EMA20 ao gráfico
    fig.add_trace(go.Scatter(
        x=df['time'],
        y=df['EMA20'],
        line=dict(color='blue', width=1),
        name='EMA20'))
    
    # Adiciona marcadores onde o pullback é possível
    fig.add_trace(go.Scatter(
        x=df['time'],
        y=df['pullback_marker'],
        mode='markers',
        marker=dict(color='orange', size=8, symbol='triangle-down'),
        name='Possível Pullback'))
    
    # Plota os níveis de Fibonacci se existirem
    if fib_levels:
        colors = {'0%': 'purple', '38.2%': 'red', '50%': 'green', '61.8%': 'blue', '100%': 'purple'}
        for level_name, level_price in fib_levels.items():
            fig.add_shape(type='line',
                          x0=df_segment['time'].iloc[0],
                          y0=level_price,
                          x1=df_segment['time'].iloc[-1],
                          y1=level_price,
                          line=dict(color=colors.get(level_name, 'purple'), dash='dash'))
            # Adiciona anotações para os níveis
            fig.add_annotation(x=df_segment['time'].iloc[-1], y=level_price,
                               text=level_name,
                               showarrow=False,
                               yshift=10)
    
    # Configura o layout do gráfico
    fig.update_layout(title='Gráfico de Candlestick BTCUSD 5 Minutos com Pullback',
                      xaxis_title='Tempo',
                      yaxis_title='Preço (USD)')
    
    # Exibe o gráfico
    fig.show()
    

    Explicação do Código:

    • Importações e Inicialização: Importamos as bibliotecas necessárias e inicializamos a conexão com o MetaTrader 5.

    • Obtenção de Dados: Usamos mt5.copy_rates_range para obter os dados históricos de BTCUSD no timeframe de 5 minutos.

    • Processamento de Dados:

      • Convertendo os dados para um DataFrame do pandas para facilitar a manipulação.
      • Calculamos a EMA de 20 períodos para ajudar a identificar a tendência.
      • Determinamos a tendência atual comparando o preço de fechamento com a EMA20 e observando a inclinação da EMA20.
      • Calculamos a distância percentual entre o preço de fechamento e a EMA20 para identificar possíveis pullbacks.
      • Marcamos os pontos onde o pullback é possível.
    • Detecção de Tendência e Cálculo de Níveis de Fibonacci:

      • Identificamos onde as mudanças de tendência ocorrem e separamos os dados em segmentos de tendência.
      • Para o último segmento de tendência, calculamos os níveis de retração de Fibonacci. Esses níveis são usados para identificar possíveis regiões de pullback conforme o conceito amplamente utilizado de Fibonacci no trading.
    • Visualização:

      • Criamos um gráfico de candlestick usando o Plotly.
      • Adicionamos a EMA20 ao gráfico para visualizar a média móvel exponencial.
      • Marcamos pontos no gráfico onde há possibilidade de pullback.
      • Plotamos os níveis de Fibonacci como linhas horizontais no gráfico para indicar as regiões de pullback potenciais.
      • Configuramos o layout e exibimos o gráfico interativo.

    Nota:

    • As regiões de pullback são identificadas usando os níveis de Fibonacci, que é um dos melhores conceitos para determinar possíveis áreas onde o preço pode reverter temporariamente antes de continuar na direção da tendência dominante.
    • Esse código pode ser expandido e ajustado conforme necessário para incluir outros indicadores ou lógica adicional para análise de mercado.

    Espero que este código atenda às suas necessidades!