¿Hay alguna interfaz útil para el backtesting de acciones?

El backtesting es la función más básica de una interfaz de stock, generalmente mientras no esté mal hecho, es básicamente confiable, pero algunos son más difíciles de entender, pero algunos tienen ciertas ventajas técnicas. Por ejemplo, el primer informe de error: Tal vez el mercado no ha existido durante tanto tiempo, y si se devuelve Ninguno, un error dará como resultado una referencia directa. Estos lenguajes de programación a menudo necesitan considerar varios errores por sí mismos, y la sintaxis del lenguaje Mai es simple, pero el grado de personalización no es fuerte y, a veces, será más problemático usarlo al programar.

Por supuesto, no importa cuán buena sea la herramienta, no es tan buena como escribirla usted mismo. Después de obtener la interfaz de datos, podemos escribir la función de backtest nosotros mismos. La estrategia es que si compra, comprará la mitad de la posición Si vende, también venderá la mitad de una posición. El código de backtest correspondiente es el siguiente:

import datetime

from quantitative.data_process import get_day_name_data
from quantitative.rsrs import sell_or_buy


class BackTrader:
    def __init__(self,
                 cash: float = 50000,
                 stock: str = "000001",
                 reverso: float = 0):
        """
        构造回测对象。根据输入的股票代码，然后给定资金池，模拟买入卖出。
        :param cash: 初始资金数量  float
        :param stock:  股票代码    str
        :param reverso: 每次交易手续费率 float
        """

        # 利用数据，初始化交易所对象和策略对象。
        self.stock = stock  # 股票代码
        self.init_cash = cash  # 初始投入资金
        self.cash = cash  # 当前现金持有量
        self.lst = []  # 股票池
        self.buy_num = 0  # 总计买入的股票数量
        self.sell_num = 0  # 总计卖出的股票数量

    def sell(self, close, closeout=False):
        price = close * 100  # 一手的价格
        sell_num = len(self.lst) // 2
        if closeout:  # 强制平仓，
            self.cash += len(self.lst) * price
            self.lst = []  # 股票池没有股票了
            self.sell_num += len(self.lst)
        elif len(self.lst) == 0:  # 这个表示没有持仓
            print(f'没有持仓哦，无法卖出股票')
            pass
        elif len(self.lst) == 1:  # 只有一手股票
            self.cash += price
            self.lst.pop()
            self.sell_num += 1
        else:  # 多于两手股票
            #
            for i in range(sell_num):
                self.cash += price
                self.lst.pop()
                self.sell_num += 1
            print(f'卖出了{sell_num}手股票，当前持有股票量{len(self.lst)},当前现金持有量{self.cash}')

    def buy(self, close):
        price = close * 100  # 一手的价格
        try:
            num = int(self.cash // price)
            if num == 0:
                print("Oh，sorry，没有现金了")
                pass
            if num == 1:
                self.buy_num += 1
                self.lst.append(price)
                print(f'现金不多了，仅可以买入1手哦')
            else:
                buy_num = num // 2
                print(f'金主，你可以买入{num}手，买入了{buy_num}手')
                for i in range(buy_num):
                    self.lst.append(price)
                    self.cash -= price
                self.buy_num += buy_num
                print(f'当前现金持有量{self.cash},股票持有量{len(self.lst)}')
        except:
            print(f'{price} 是不可以运算的')
    def run(self, begin, end):
        """
        运行回测，迭代历史数据，执行模拟交易并返回回测结果。
        """
        begin_date = datetime.datetime.strptime(begin, "%Y-%m-%d")
        end_date = datetime.datetime.strptime(end, "%Y-%m-%d")
        days = (end_date - begin_date).days
        close = 0
        for i in range(days):
            date_str = (begin_date + datetime.timedelta(days=i)).strftime("%Y-%m-%d")
            flag = sell_or_buy(self.stock, date_str)
            close = get_day_name_data(self.stock, date_str, "收盘价")
            if isinstance(close, str):
                continue
            if flag == "BUY":
                self.buy(close)
            elif flag == "SELL":
                self.sell(close)
            if i == days - 1: # 最后一天强制平仓
                self.sell(close)
            # print(self.cash)
        self.cash += len(self.lst) * close
        print(self.cash)
        print("收益率", (self.cash - self.init_cash) / self.init_cash)
        print(self.lst)
        print("购买次数", self.sell_num)
        print("出售次数", self.buy_num)


# 每日数据更新，寻找股票数据，需要判断当日的数据是否已经写入到数据库中了
def get_stock_code():
    from database import MG
    from database import MONGO_STOCK
    client = MG(MONGO_STOCK)
    stock_code = client.db['stock_code']
    # 查找整个中国所有的股票
    res = stock_code.find({})
    for i, item in enumerate(res):
        yield item['证券简称'], item['code']

if __name__ == '__main__':
    for item in get_stock_code():
        bt = BackTrader(cash=50000, stock=item[1])
        begin = "2022-01-10"
        end = "2022-06-30"
        bt.run(begin, end)
        print(item)

Ok, entonces, ¿qué tipo de interfaz de datos es adecuada para su uso? Aquí hay algo sobre lo que puede aprender: es relativamente simple de obtener, puede encontrarlo en https://gitee.com/l2gogogo, y también es compatible con el lenguaje Python. Puede suscribirse después de obtener una cuenta, y luego podemos acoplar y escribir después de que nosotros mismos hagamos el desarrollo secundario.