4.4 Como implementar estratégias em Python

Resumo

No artigo anterior, aprendemos sobre a introdução à linguagem Python, a sintaxe básica, a estrutura de estratégia e muito mais. Embora o conteúdo fosse chato, mas é uma habilidade necessária no desenvolvimento de sua estratégia de negociação. Neste artigo, vamos continuar o caminho do Python com uma estratégia simples, passo a passo para ajudá-lo a alcançar uma estratégia quantitativa de negociação viável.

Introdução à Estratégia

Entre muitas estratégias de negociação, a estratégia do canal Donchian deve ser uma das estratégias de avanço mais clássicas.

Mais tarde, nos Estados Unidos, ocorreram os famosos eventos de treinamento de comerciantes turtle, que tiveram um grande sucesso na história da negociação de valores mobiliários.

A estratégia de negociação de avanço é adaptada à tendência relativamente suave das variedades de negociação. A maneira mais comum de avanço é usar a relação posicional relativa entre o suporte de preço e a resistência para determinar a posição de negociação específica. A estratégia de canal Donchian nesta seção também é baseada neste princípio.

Regras de estratégia do Canal de Donchian

O canal de Donchian é um indicador orientado para a tendência, e sua aparência e sinal são um pouco semelhantes ao indicador da Banda de Bollinger. No entanto, seu canal de preço é construído de acordo com os preços mais altos e mais baixos em um determinado período. Por exemplo: o trilho superior é calculado pelo preço mais alto da linha 50 k mais recente; o trilho inferior é calculado pelo preço mais baixo da linha 50 k mais recente.

como mostrado acima: este indicador com a curva composta por três cores diferentes, a configuração padrão é o preço mais alto e o mais baixo no ciclo 20 para exibir a volatilidade dos preços.

Se os preços subirem acima do trilho superior, o sinal de compra aparecerá; vice-versa, se o preço cair abaixo do trilho inferior, o sinal de venda aparecerá.

Método de cálculo do canal de Donchian

Na plataforma FMZ Quant, o cálculo do canal Donchian é simples, você pode apenas acessar o preço mais alto ou mais baixo no ciclo dado, como mostrado abaixo: a 5a linha é para obter o preço mais alto de 50 ciclos, a 6a linha é para obter o preço mais baixo de 50 ciclos.

def main(): # program entry
    exchange.SetContractType("this_week") # set the variety type by using the weekly k-line 
    while True: # enter the loop
        records = exchange.GetRecords() # get the k line array
        upper = TA.Highest(record, 50, 'high') # get the highest price of 50 cycles
        lower = TA.Lowest(record, 50, 'low') # get the lowest price of 50 cycles
        middle = (upper + lower) / 2 # calculate the average value of upper and lower rails 
        Log("upper rail: ", upper) # print the upper rail value in the log
        Log("lower rail: ", lower) # print the lower rail value in the log
        Log("middle rail: ", middle) # print the middle rail value in the log

Estratégia lógica

Existem muitas maneiras de usar o canal de Donchian, que pode ser usado sozinho ou em combinação com outros indicadores. Nesta seção, vamos usá-lo da maneira mais fácil. Ou seja: quando os preços atravessam o trilho superior, o que significa que ele quebra acima da linha de pressão, o poder de compra é forte, ele formou uma onda de energia crescente, é gerado o sinal de compra; quando o preço quebra abaixo do trilho inferior, o que significa que ele quebra abaixo da linha de suporte, é gerado o sinal de venda.

Se o preço voltar a cair para o meio do canal após a abertura da posição longa, acreditamos que a força do poder de compra está enfraquecendo, ou a força do poder de venda está fortalecendo, e o sinal de abertura da posição curta é gerado; o mesmo princípio se aplica à abertura da posição curta

Condições de negociação

• Posição longa aberta: Se não houver posição mantida e o preço de fechamento for superior à linha de chegada

• Posição curta aberta: Se não houver posição mantida e o preço de encerramento for inferior ao nível inferior

• Fechamento de posição longa: se a posição longa estiver atualmente mantida e o preço de fechamento for inferior ao preço médio

• Fechamento de posição curta: se a posição curta estiver atualmente mantida e o preço de fechamento for superior à linha do meio

Implementação do código de estratégia

O primeiro passo na implementação da estratégia é obter os dados primeiro, porque os dados são uma parte prévia da estratégia de negociação.

O próximo passo é calcular a lógica de negociação com base nestes dados; o passo final é negociar de acordo com a lógica.

Passo 1: Utilização da biblioteca de classes comerciais

Você pode pensar na biblioteca de classe de negociação como um módulo funcional. A vantagem de usar uma biblioteca de classe de negociação é que ela permite que você se concentre em escrever lógica de estratégia. Por exemplo, quando usamos a biblioteca de classe de negociação, para abrir ou fechar uma posição, podemos usar diretamente a interface API na biblioteca de classe de negociação; mas se não usarmos a biblioteca de classe de negociação, precisamos obter o preço de mercado ao abrir a posição. Precisamos considerar a questão das ordens não executadas e a questão das ordens de retirada, e assim por diante.

def main();
    wile true:
        obj = ext.NewPositionManager() # using the trading class library
        # followed by strategy logic and placing order part

A parte de codificação acima é a estrutura de estratégia CTA usando a ferramenta FMZ Quant. Este é um formato de codificação fixo, e todo o código de lógica de negociação começará na linha 4.

Passo 2: Obtenha todos os tipos de dados

Pensem nisso, que tipo de dados precisamos? de nossa lógica de negociação estratégica, primeiro precisamos obter o status da posição atual, e, em seguida, comparar o preço de fechamento com o indicador Bollinger Band trilhos superior, médio e inferior.

• Obter dados da linha K.

O primeiro é obter a matriz de dados de linha K e o preço de fechamento da linha K atual, com a matriz de linha K, podemos calcular o período de ciclo N do preço mais alto e mais baixo através da interface API. pode ser escrito assim:

def main(): # main function
    exchange.SetContractType("this_week") # set the variety type by using the weekly k-line 
    while True: # enter the loop
        records = exchange.GetRecords() # get the k line array
        if len(records) < 50: continue # if the number of K line is less than 50, skip this loop.
        close = records[len(records) - 1].Close # get the closing price of the latest k-line

Como mostrado acima:

Linha 4: Obtenha a matriz de linhas K, que é um formato fixo.

Linha 5: Filtrar o comprimento da linha K, porque o parâmetro para calcular o indicador do canal de Donchian é 50, quando o número de linha K é menor que 50, é impossível calcula-lo.

Linha 6 : Usamos o código "records[ len (records) - 1] " para obter os últimos dados da matriz da linha K, que são os últimos dados da linha K. Estes dados são um objeto, que contém: o preço de abertura, o preço mais alto, o menor e o preço de fechamento, também o volume de negociação, tempo e outros dados, uma vez que é um objeto, então usamos apenas .Close para obter o último preço de fechamento da linha K.

• Obter dados de posição

A informação de posição é uma condição muito importante na estratégia quantitativa de negociação. Quando as condições de negociação são estabelecidas, é necessário julgar se colocar uma ordem pelo status da posição e pelo número de posições. Por exemplo, quando as condições para abrir posições longas são estabelecidas, se houver posição de detenção, não colocar a ordem; se não houver posição de detenção, colocar a ordem. Desta vez, encapsulamos diretamente a informação de posição em uma função, podemos simplesmente chamar essa função para usá-la. assim:

# get the position information function
def mp():
    positions = exchange.GetPosition() # get the holding position array
    if len(position) == 0: # if the holding position array is 0
        return 0 # meaning currently has no position holding, return 0
    for i in range(len(position)): # Traversing the position array
        if (position[i]['Type'] == PD_LONG): 
            return 1 # if there are long position holding, return 1
        elif (position[i]['Type'] == PD_SHORT):
            return -1 # if there are short position holding, return -1
        
def main(): # main function
    exchange.SetContractType("this_week") # set the variety type by using the weekly k-line
    while True: # enter the loop
        records = exchange.GetRecords() # get the k line array
        if len(records) < 50: continue # if the number of K line is less than 50, skip this loop.
        close = records[len(records) - 1].Close # get the closing price of the latest k-line
        position = mp() # get the position information function

Como mostrado acima:

Esta é uma função que obtém as informações de posição. Se houver posição longa, o valor é 1; se houver posição curta, o valor é -1; se não houver posição, o valor é 0.

Linha 2: Crie uma função com o nome mp. Esta função não tem parâmetros.

Linha 3: Obter a matriz de posição, que é um formato fixo.

Linha 4: Determine o comprimento da matriz de posições. Se o seu comprimento é igual a 0, significa que não tem posição de retenção, retorna 0.

Linha 6 : Usando o loop for, começando a atravessar esta matriz, a seguinte lógica é muito simples, se estiver segurando posição longa, retorna 1 ; se estiver segurando posição curta, retorna -1.

Linha 18: Chamar a função de informação de posição mp.

• Adquirir o preço mais alto e mais baixo das 50 linhas K mais recentes

Na ferramenta de negociação quantitativa do FMZ Quant, você pode usar diretamente as funções " TA.Highest " e " TA.Lowest " sem ter que escrever seus próprios cálculos lógicos. E a função TA.Highest e TA.Lowest retorna um resultado dos valores específicos em vez de uma matriz. Isso é muito conveniente.

# get the position information function
def mp():
    positions = exchange.GetPosition() # get the holding position array
    if len(position) == 0: # if the holding position array is 0
        return 0 # meaning currently has no position holding, return 0
    for i in range(len(position)): # Traversing the position array
        if (position[i]['Type'] == PD_LONG): 
            return 1 # if there are long position holding, return 1
        elif (position[i]['Type'] == PD_SHORT):
            return -1 # if there are short position holding, return -1
        
def main(): # main function
    exchange.SetContractType("this_week") # set the variety type by using the weekly k-line
    while True: # enter the loop
        records = exchange.GetRecords() # get the k line array
        if len(records) < 50: continue # if the number of K line is less than 50, skip this loop.
        close = records[len(records) - 1].Close # get the closing price of the latest k-line
        position = mp() # get the position information function
        upper = TA.Highest(record, 50, 'High') # get the highest price of 50 cycles
        lower = TA.Lowest(record, 50, 'Low') # get the lowest price of 50 cycles
        middle = (upper + lower) / 2 # calculate the average value of the upper and lower rail

Como mostrado acima:

Linha 19: chamar a função TA.Highest para obter o preço mais alto de 50 ciclos

Linha 20: chamar a função TA.Lowest para obter o preço mais baixo de 50 ciclos

Linha 21: calcular o valor médio do carril superior e inferior de acordo com o preço mais alto e o mais baixo de 50 ciclos

Etapa 3: Encomenda e negociação

Com os dados acima, podemos escrever a lógica de negociação e a parte de colocação de ordem agora. Também é muito simples, a mais usada é a declaração if, que pode ser descrita como: se a condição 1 e a condição 2 forem verdadeiras, coloque a ordem; se a condição 3 ou a condição 4 forem verdadeiras, coloque a ordem.

# get the position information function
def mp():
    positions = exchange.GetPosition() # get the holding position array
    if len(position) == 0: # if the holding position array is 0
        return 0 # meaning currently has no position holding, return 0
    for i in range(len(position)): # Traversing the position array
        if (position[i]['Type'] == PD_LONG): 
            return 1 # if there are long position holding, return 1
        elif (position[i]['Type'] == PD_SHORT):
            return -1 # if there are short position holding, return -1
        
def main(): # main function
    exchange.SetContractType("this_week") # set the variety type by using the weekly k-line
    while True: # enter the loop
        records = exchange.GetRecords() # get the k line array
        if len(records) < 50: continue # if the number of K line is less than 50, skip this loop.
        close = records[len(records) - 1].Close # get the closing price of the latest k-line
        position = mp() # get the position information function
        upper = TA.Highest(record, 50, 'High') # get the highest price of 50 cycles
        lower = TA.Lowest(record, 50, 'Low') # get the lowest price of 50 cycles
        middle = (upper + lower) / 2 # calculate the average value of the upper and lower rail
        obj = ext.NewPositionManager() # using the trading class library
        if position > 0 and close < middle: # If currently holding long position, and the closing price is less than the middle rail
            obj.CoverAll() # close all position
        if position < 0 and close > middle: # If currently holding short position, and the closing price is greater than the middle rail
            obj.CoverAll() # close all position
        if position == 0: # if currently holding no position
            if close > upper: # if the closing price is greater than the middle rail
                obj.OpenLong("this_week", 1) # open long position
            elif close < lower: # if the closing price is less than the middle rail
                obj.OpenShort("this_week", 1) # open short position

Como mostrado acima:

Linha 22: Utilizando a biblioteca de classes comerciais, este é um formato fixo

Linhas 23, 24 : Esta é uma declaração de posição longa de fechamento que usa os operadores de comparação e operadores lógicos que aprendemos anteriormente, o que significa que se a posição atual for uma posição longa e o preço de fechamento for inferior ao nível médio, feche todas as posições.

Linhas 25, 26: Esta é uma declaração de posição curta de fechamento que usa os operadores de comparação e operadores lógicos que aprendemos anteriormente, o que significa que se a ordem atual for uma posição curta e o preço de fechamento for maior que o trilho do meio, feche todas as posições.

Linha 27: Determine o estado da posição atual.

Linhas 28, 29: Determinar se o preço de encerramento é superior ao nível superior.

Linhas 30, 31: Determinar se o preço de fechamento é inferior ao nível inferior.

Resumindo

Acima, aprendemos cada passo para desenvolver uma estratégia quantitativa completa usando Python, incluindo: introdução da estratégia, método de cálculo do canal Donchian, lógica da estratégia, condições de negociação, implementação do código da estratégia, etc. Esta seção é apenas uma estratégia simples.

Anúncio da secção seguinte

No desenvolvimento de estratégias de negociação quantitativas, do ponto de vista da velocidade de execução da linguagem de programação, qual é o mais rápido? deve ser o C ++. Especialmente no campo dos derivados financeiros e da negociação de alta frequência. O C ++ é único na especificidade da linguagem e tem vantagens em cálculos numéricos. Em comparação com JavaScript e Python, sua velocidade pode ser aumentada em várias ordens de magnitude. Se você quiser ir para o campo dos derivados financeiros ou da negociação de alta frequência no futuro. Este será o curso que você não deve perder.

Exercícios após a escola

1. Começar pelo básico e implementar a estratégia desta secção.

2. Tente adicionar um indicador de média móvel à estratégia desta secção para reduzir a frequência de negociação.

Mais.