精华内容
下载资源
问答
  • 37-量化策略回测:创建属于自己的回测框架 38-量化策略回测:如何利用聚宽平台回测交易策略【本次加推篇】 39-量化策略回测:基于BackTrader建立双均线策略 40-远程下单方案:微信机器人实时提醒交易 41-远程下单...

    导览

    本文为掘金小册课程加推篇!小册还在持续加推中,敬请期待!!!目前已经加推20节!!!

    超值的43节课程!从目录就能看出来!

    1-贯穿小册:Python金融数据分析实战型项目

    2-前置基础:量化交易及应用场景简介

    3-前置基础:开发环境及基础工具说明

    4-前置基础:创建一个Python文件的细节

    5-前置基础:Python变量类型及动态特性

    6-前置基础:玩转Python遍历工具for..in

    7-前置基础:无可或缺的Python异常处理

    8-前置基础:NumPy模拟随机漫步理论

    9-前置基础:Pandas构建DataFrame股票数据

    10-前置基础:Matplotlib函数式绘图的方式

    11-前置基础:Matplotlib对象式绘图的方式

    12-前置基础:Matplotlib模拟随机漫步轨迹

    13-前置基础:从概率角度谈市场中的博弈

    14-股票数据获取:Pandas金融模块获取股票数据

    15-股票数据获取:差异化分析常用股票数据接口

    16-股票数据获取:详解网络爬虫的原理和过程

    17-股票数据获取:爬虫方式获取行业板块数据

    18-股票数据获取:爬虫抓取东方财富网股吧帖子

    19-股票数据分析:全方位访问DataFrame格式股票数据

    20-股票数据分析:遍历DataFrame格式股票数据的方法

    21-股票数据分析:股票分时明细数据的处理与转换

    22-股票数据分析:除权数据前复权和后复权处理

    23-股票数据可视化:自定义Matplotlib版股票行情界面

    24-股票数据可视化:pyecharts实现Web版股票行情界面

    25-股票数据可视化:pyecharts从V0.5至V1版的转变

    26-股票数据可视化:TA-Lib技术指标库的扩展应用

    27-股票数据可视化:用TA-Lib封装更灵活的指标库

    28-股票交易策略:线性回归算法建立选股策略

    29-股票交易策略:基于欧奈尔RPS指标选股策略

    30-股票交易策略:海龟择时策略入门量化交易

    31-股票交易策略:收益与风险维度度量策略效果

    32-股票交易策略:择时策略融入ATR风险管理

    33-股票交易策略:择时策略融入ATR动态仓位管理

    34-股票交易策略:蒙特卡洛算法最优化策略参数

    35-股票交易策略:基于凯利公式的仓位管理

    36-量化策略回测:扒一扒量化回测中常见的陷阱

    37-量化策略回测:创建属于自己的回测框架

    38-量化策略回测:如何利用聚宽平台回测交易策略【本次加推篇】

    39-量化策略回测:基于BackTrader建立双均线策略

    40-远程下单方案:微信机器人实时提醒交易

    41-远程下单方案:SMTP邮件实时提醒交易

    42-效率优化措施:Python扩展C/C++加速执行

    43-结尾篇:贯穿知识点才能学以致用

    前言

    我们经过了自己动手搭建量化回测框架这个过程之后,能够对回测有一定的认识。

    接下来可以探索下那些现有的回测框架或者平台,试着找到适合自己风格的方式。

    这里我们选一个比较普及的线上回测平台——聚宽,通过几个简单的例程来熟悉下这个平台的使用特点。

    编程框架

    首先文件中要导入jqdata其他使用到的库。如下所示:

    # 导入函数库
    import jqdata
    
    import pandas as pd
    import numpy as np
    import talib as tl

    基本的框架可以概括为“初始化+周期循环”框架。

    首先建立一个初始化函数initialize,在函数里面可以设置基准、滑点、手续费等初始化操作。

    然后选择run_daily/run_weekly/run_monthly中的一种周期去循环执行策略。

    比如官网上最简单的一个例程,如下所示:

    # 导入聚宽函数库
    import jqdata
    # 初始化函数,设定要操作的股票、基准等等def initialize(context):
        # 定义一个全局变量, 保存要操作的股票
        # 000001(股票:平安银行)
        g.security = '000001.XSHE'
        # 运行函数
        run_daily(market_open, time='every_bar')
        if g.security not in context.portfolio.positions:
            order(g.security, 1000)
        else:
            order(g.security, -800)
    

    这个例程里先在初始化函数 initialize里指定操作'000001.XSHE'平安银行,然后就是每天调用market_open函数,每次调用时候判断没有股票时就买入1000股,有股票时卖出800股……虽然是一个很没意义的策略,但是对理解如何在聚宽上写策略还是比较直观的。

    大家在编写策略的时候是要使用聚宽上封装了的API函数的,可以查看官网的介绍。比如set_benchmark设置基准、set_order_cost设置佣金/印花税、set_slippage设置滑点、use_real_price设置动态复权(真实价格)模式、order按股数下单、get_ticks获取tick数据等等,不得不说从这方面来看使用上还是蛮方便的。

    单股票双均线择时策略

    我们拿双均线策略这个入门的策略来回测一下,M5上穿M10时达到一定幅度时买入,M5下穿M10时卖出。

    在初始化函数中设定操作的股票、基准、开启动态复权模式、设定每天调用的market_open函数。

    接下来策略的逻辑实现都在market_open函数中。

    先得到M5和M10的均线数值,attribute_history函数得到的是最近N日的收盘价数据,以close_data_5为例,每天会返回如下数值(每天都会执行一次函数,返回N日的收盘价),然后求平均即为MA5。

    剩下的就是买卖点的逻辑判断,比如出现金叉买入、出现死叉卖出之类的。最后record函数还可以选择绘制收盘价、均线的走势。

    整体代码我们会更新到掘金小册课程。

    回测界面如下所示:

    多股票双均线择时策略

    很多时候我们买股票都是买多只股票的,那么如何回测多只股票情况下的双均线择时策略呢?

    比如当某只股票M5上穿M10时达到一定幅度时买入100股,M5下穿M10时则卖出。

    其实主要更改在于建立一个股票池,如下所示:

    # 设置我们要操作的股票池
    g.stocks = ['000001.XSHE','000002.XSHE','000004.XSHE','000005.XSHE']
    

    然后在每次调用交易执行中不断去循环判断这几个股票是否达到交易条件。

    回测界面如下所示:


    总结

    聚宽平台给量化交易者提供了一个很不错的平台,使用过程中,我的感觉是关于内置的API函数还是比较灵活的,特别是与数据相关的接口。前提是要非常熟悉这些接口的特点和使用方法。

    不过回测过程中速度确实有点慢,编写和调试代码的环境和我本地相比是有点不太灵活。

    总体来说瑕不掩瑜吧,大家使用后有什么想法吗?可以在留言区谈谈。

    代码已更新至掘金小册,请查收!

    更多量化交易内容可扫码以下课程!—————————————————海报未更新,直接扫码!
    
     扫码加入星球!
    一起搭建属于自己的交易系统
    —————————————————
    
    微信关注:‘元宵大师带你用Python量化交易’
    
    
    展开全文
  • 打开聚宽,https://www.joinquant.com/ 注册登录 策略 新建股票策略 填入下面代码: def initialize(context): g.stock='000300.XSHG' g.N=60 g.high=0 g.drawdown=0.4 set_benchmark('000300.XSHG') ...

    点击查看jqdata sdk 详细内容

     

    打开聚宽,https://www.joinquant.com/

    注册登录

    策略

    新建股票策略

    填入下面代码:

    利用凯利公式进行投资测试,基准为沪深300

    def initialize(context):
        g.stock='000300.XSHG'
        g.N=60
        g.high=0
        g.drawdown=0.4
      
        set_benchmark('000300.XSHG')
        set_option('use_real_price',True)
        log.set_level('order','error')
        
    def handle_data(context,data):
        g.high=max(g.high,context.portfolio.total_value)
        close=list(attribute_history(g.stock, g.N, '1d', 'close').close)
        v=[(s2/s1) for (s1,s2) in zip(close[:-1],close[1:])]
        print(v)
        m=mean(v)
        s=np.std(v)
        mu=np.log(m)
        sigma2=np.log(s**2/m**2 + 1)
        #f_star=np.abs(mu/sigma2)  ##取绝对值
        f_star=mu/sigma2  
        #print("m is %s " % m)
        #print("f_star is %s " % f_star)
        init_value = context.portfolio.total_value*g.drawdown*f_star*0.5
        # print("*****************"*3)
        # print(init_value)
        print("---"*20)
        print(f_star)
    
    
        if m>0:
            order_target_value(g.stock,init_value)
        else:
            order_target_value(g.stock,0)
    
    
            

    然后选择日期,金额 100000

    然后就可以回测了

    不提供任何投资建议,学习研究用

    希望对大家有所帮助

    你会发现线上数据有局限性,不如本地运行快等,建议选择本地数据

    展开全文
  • 1.用户编写的策略脚本,和聚宽风格保持一致,代码可以在聚宽平台运行。userconfig = { "start":"2018-01-01", "end":"2018-03-29" } def initialize(context): context...

    1.用户编写的策略脚本,和聚宽风格保持一致,代码可以在聚宽平台运行。

    userconfig = {
        "start":"2018-01-01",
        "end":"2018-03-29"
    }
    
    def initialize(context):
        context.current_dt = '2018-01-01'
        g.today = "2018-03-23"
        run_daily(market_open, time='open')
    
    def market_open(context):
        print('context:',context.current_dt)
        pass
    
    def handle_data(context, data):
        #print('HANDLE:',context.current_dt)
        pass

    2.策略环境配置

    # -*- coding: utf-8 -*-
    from userStrategy import userconfig
    config = {
      "mod": {
        "stock": {
          "enabled": True,
        },
        "future": {
            "enabled": False,
        }
      }
    }
    from events import EventBus
    class Env(object):
        _env = None
        def __init__(self, config):
            Env._env = self
            self.config = config
            self.event_bus = EventBus()
            self.usercfg = userconfig
            self.global_vars = None
            self.current_dt = None
            self.event_source = None
    
        @classmethod
        def get_instance(cls):
            """
            返回已经创建的 Environment 对象
            """
            if Env._env is None:
                raise RuntimeError("策略还未初始化")
            return Env._env
    
        def set_global_vars(self, global_vars):
            self.global_vars = global_vars
    
        def set_event_source(self, event_source):
            self.event_source = event_source

    3.事件及事件注册机

    # -*- coding: utf-8 -*-
    from enum import Enum
    from collections import defaultdict
    
    
    class Event(object):
        def __init__(self, event_type, **kwargs):
            self.__dict__ = kwargs
            self.event_type = event_type
    
        def __repr__(self):
            return ' '.join('{}:{}'.format(k, v) for k, v in self.__dict__.items())
    
    
    class EventBus(object):
        def __init__(self):
            self._listeners = defaultdict(list)
    
        def add_listener(self, event, listener):
            self._listeners[event].append(listener)
    
        def prepend_listener(self, event, listener):
            self._listeners[event].insert(0, listener)
    
        def publish_event(self, event):
            for l in self._listeners[event.event_type]:
                # 如果返回 True ,那么消息不再传递下去
                if l(event):
                    break
    
    class EVENT(Enum):
        # 股票
        STOCK = 'stock'
        # 期货
        FUTURE = 'future'
        #事件
        TIME = 'time'
    
    def parse_event(event_str):
        return EVENT.__members__.get(event_str.upper(), None)
    4.事件分发器
    from  events import  EVENT,Event
    
    class Executor(object):
        def __init__(self, env):
            self._env = env
    
        KNOWN_EVENTS = {
            EVENT.TICK,
            EVENT.BAR,
            EVENT.BEFORE_TRADING,
            EVENT.AFTER_TRADING,
            EVENT.POST_SETTLEMENT,
        }
    
        def run(self, bar_dict):
    
            start = self._env.usercfg['start']
            end = self._env.usercfg['end']
            frequency = self._env.config.base.frequency
            event_bus = self._env.event_bus
    
            for event in self._env.event_source.events(start, end, frequency):
                if event.event_type in self.KNOWN_EVENTS:
                    self._env.calendar_dt = event.calendar_dt
                    #self._env.trading_dt = event.trading_dt
    
                    event_bus.publish_event(event)

    5.业务处理模块加载及handler

    # -*- coding: utf-8 -*-
    
    from collections import OrderedDict
    from importlib import import_module
    
    class ModHandler(object):
        def __init__(self):
            self._env = None
            self._mod_list = list()
            self._mod_dict = OrderedDict()
    
        def set_env(self, environment):
            self._env = environment
    
            config = environment.config
    
            for mod_name in config['mod']:
                if config['mod'][mod_name]['enabled'] == False:
                    continue
                self._mod_list.append(mod_name)
    
        def start_up(self):
            for mod_name in self._mod_list:
                #动态加载模块
                mod = import_module(mod_name)
                for i in mod.__all__:
                    i(self._env.event_bus)
    # -*- coding: utf-8 -*-
    from events import EVENT
    __all__ = [
    ]
    def export_as_api(func):
        __all__.append(func)
        return func
    
    @export_as_api
    def startup(event_bus):
        event_bus.add_listener(EVENT.STOCK, handler)
        print('load and register future mod')
    
    def handler(event):
        print('do future handler success')
        pass
    # -*- coding: utf-8 -*-
    import random
    from events import EVENT
    __all__ = [
    ]
    def export_as_api(func):
        __all__.append(func)
        return func
    
    @export_as_api
    def startup(event_bus):
        event_bus.add_listener(EVENT.STOCK, handler)
        print('load and register stock mod')
    
    def handler(event):
        rd = random.randint(0,9)
        if rd == 7:
            print('成交记录:UserTrade({''secu:000001.XHSG,''order_id'': 1522310538, ''trade_id'': 1522310538, ''price'': 10.52, ''amount'': 2300')
        if rd == 5:
            print('成交记录:UserTrade({''secu:000254.XHSG,''order_id'': 1522310538, ''trade_id'': 1522310538, ''price'': 23.52, ''amount'': 1700')
        if rd == 2:
            print('成交记录:UserTrade({''secu:600012.XHSG,''order_id'': 1522310538, ''trade_id'': 1522310538, ''price'': 13.52, ''amount'': 1700')
        pass

    6.处理策略文本主程序

    # -*- coding: utf-8 -*-
    from Env import  Env, config
    from Mod import  ModHandler
    from events import EVENT, Event
    from globalVars import GlobalVars
    from CodeLoader import  CodeLoader
    from strategy_context import StrategyContext
    import api
    from api import Scheduler
    import  datetime
    def run_file(strategy_file_path):
        #加载configenv
        env = Env(config)
        #启动加载模块
        mod = ModHandler()
        #加载模块中注入config
        mod.set_env(env)
        #启动加载
        mod.start_up()
    
        loader = CodeLoader(strategy_file_path)
        scope = {}
        scope = loader.load(scope)
        env.set_global_vars(GlobalVars())
        scope.update({
            "g": env.global_vars
    
        })
        env.current_dt =  datetime.datetime.strptime(env.usercfg['start'], "%Y-%m-%d")
        context = StrategyContext()
        scheduler = Scheduler()
        scheduler.set_user_context(context)
        api._scheduler = scheduler
    
        f = scope.get('initialize', None)
        f(context)
    
        data = {}
        f1 = scope.get('handle_data', None)
        f1(context,data)
    
    
    
    
        #事件发布
        # event_bus = env.event_bus
        # event_bus.publish_event(Event(EVENT.STOCK))
        # event_bus.publish_event(Event(EVENT.FUTURE))

    7.类加载器

    import codecs
    import copy
    from six import exec_
    
    class CodeLoader:
        def __init__(self, strategyfile):
            self._strategyfile = strategyfile
    
        def compile_strategy(self, source_code, strategyfile, scope):
            code = compile(source_code, strategyfile, 'exec')
            exec_(code, scope)
            return scope
        #
        def load(self, scope):
            with codecs.open(self._strategyfile, encoding="utf-8") as h:
                source_code = h.read()
            source_code = 'from api import *\n' + source_code
            return self.compile_strategy(source_code, self._strategyfile, scope)

    8.api

    # -*- coding: utf-8 -*-
    from Env import Env
    import datetime
    from  events import Event, EVENT
    
    _scheduler = None
    
    def run_daily(func, time):
        _scheduler._run_daily(func, time)
    
    class Scheduler(object):
        def __init__(self):
            # self._registry = []
            # self._today = None
            # self._this_week = None
            # self._this_month = None
            # self._last_minute = 0
            # self._current_minute = 0
            # self._stage = None
            self._ucontext = None
            # self._frequency = frequency
    
            # event_bus = Environment.get_instance().event_bus
            # event_bus.add_listener(EVENT.PRE_BEFORE_TRADING, self.next_day_)
            # event_bus.add_listener(EVENT.BEFORE_TRADING, self.before_trading_)
            # event_bus.add_listener(EVENT.BAR, self.next_bar_)
    
        def set_user_context(self, ucontext):
            self._ucontext = ucontext
    
        def _run_daily(self,func, time):
            env = Env.get_instance()
            event_bus = env.event_bus
            eventSrc = []
            if time == 'open':
                start = datetime.datetime.strptime(env.usercfg['start'], "%Y-%m-%d")
                end = datetime.datetime.strptime(env.usercfg['end'], "%Y-%m-%d")
                for i in range((end - start).days + 1):
                    day = start + datetime.timedelta(days=i, hours=9, minutes=30)
                    event = Event(EVENT.TIME)
                    eventSrc.append(event)
    
                    print(day)
                    event_bus.publish_event(Event(EVENT.STOCK))
                    # for i in eventSrc:
                    #    for k, v in i.__dict__.items():
                    #        print(type(k))
                    #        pass
    
    
    
    
                    func(self._ucontext)
                    self._ucontext.current_dt = day
                    env.current_dt = day
    
            pass
    9.全局g
    import six
    import pickle
    class GlobalVars(object):
        def get_state(self):
            dict_data = {}
            for key, value in six.iteritems(self.__dict__):
                try:
                    dict_data[key] = pickle.dumps(value)
                except Exception as e:
                    print('CCC')
            return pickle.dumps(dict_data)
    
        def set_state(self, state):
            dict_data = pickle.loads(state)
            for key, value in six.iteritems(dict_data):
                try:
                    self.__dict__[key] = pickle.loads(value)
                except Exception as e:
                    print('CCC')
    10.context场景

    import six
    import pickle
    class GlobalVars(object):
        def get_state(self):
            dict_data = {}
            for key, value in six.iteritems(self.__dict__):
                try:
                    dict_data[key] = pickle.dumps(value)
                except Exception as e:
                    print('CCC')
            return pickle.dumps(dict_data)
    
        def set_state(self, state):
            dict_data = pickle.loads(state)
            for key, value in six.iteritems(dict_data):
                try:
                    self.__dict__[key] = pickle.loads(value)
                except Exception as e:
                    print('CCC')

    11.执行策略的脚本

    # -*- coding: utf-8 -*-
    from main import run_file
    file_path = "./userStrategy.py"
    run_file(file_path)
    

    12所有类图


    13。测试


    14.把1中的代码拷贝至聚宽中执行


    15.结束。

    展开全文
  • 聚宽平台可以方便进行策略编写、投资研究、数据回测等各项功能,云端的python环境可以很好支持。不过使用下来也有些不便之处,比如代码调试困难,虚拟机内存1G限制等问题。有时候需要将数据倒到本地调试代码。下面...

    聚宽平台可以方便进行策略编写、投资研究、数据回测等各项功能,云端的python环境可以很好支持。不过使用下来也有些不便之处,比如代码调试困难,虚拟机内存1G限制等问题。有时候需要将数据倒到本地调试代码。

    下面简单讲下实现过程。

    一. 安装聚宽的jqdatasdk库

    必须通过这个库使用JQData。

    JQData是聚宽数据团队专门为有志于从事量化投资的金融机构、研究人员以及个人量化爱好者提供的本地量化金融数据。用户只需在本地Python环境下安装JQData数据包,输入三行代码,即可调用由聚宽数据团队专业生产的全套量化金融数据,让你轻松告别平台限制,灵活安全地完成本地化的量化研究与投资决策。

    安装JQData:打开本地终端,在python目录下使用pip输入如下语句 ,安装JQData数据包:

    pip install git+https://github.com/JoinQuant/jqdatasdk.git -i https://pypi.tuna.tsinghua.edu.cn/simple
    

    如果上述方法安装失败,请使用备选安装方法:下载JQData压缩包,解压压缩包,打开终端并切换到jqdatasdk-master文件中setup.py所在的目录下,执行 python setup.py install,也能完成安装。

    我这里第二种安装完成。(如果过程中提示需要安装一些别的库,使用 pip install ****  安装即可)

    二.  申请一个JQData试用账号

    聚宽现已开放试用JQData。想要使用JQData的用户只需提交试用申请, 进行申请即可。

    有个邀请码需要微信管理员申请,页面上有提示。

    申请成功后,userid及passwd即你在聚宽平台的用户和密码。

    三.  本地代码例子

    import pandas
    from jqdatasdk import *
    auth('userid','passwd')
    pd = get_price(security='399300.XSHE',frequency='5m')
    pd.to_csv('399300.csv', encoding = 'utf-8', index = False)
    ......

    四. 相关参考

    对生成出来的excel的各种处理参考      https://blog.csdn.net/ebzxw/article/details/80261507

    CSV格式文件处理                               https://blog.csdn.net/ebzxw/article/details/80358652

    各种图表处理参考                               https://blog.csdn.net/ebzxw/article/details/80262365

    可视化库Matplotlib使用参考                  https://blog.csdn.net/ebzxw/article/details/80469342


    展开全文
  • 利用聚宽免费数据进行量化分析

    千次阅读 2019-02-18 15:32:11
    这里简要介绍一下如何利用聚宽免费数据进行量化分析: 1、使用聚宽的量化网站平台或金融终端: 聚宽的量化网站平台网址是:https://www.joinquant.com/ 聚宽的金融终端在这个主页上就可以看到下载链接,目前提供的...
  • 前言一个完整的量化交易系统离不开人机交互功能的应用,特别是在回测阶段,我们需要不断更改参数因子、更换交易策略以应对当前的市场。因此创建完整的、功能键全的GUI用户界面至关重要。市面上也出...
  • 前言一个完整的量化交易系统离不开人机交互功能的应用,特别是在回测阶段,我们需要不断更改参数因子、更换交易策略以应对当前的市场。因此创建完整的、功能键全的GUI用户界面至关重要。前几期我们...
  • 前言一个完整的量化交易系统离不开人机交互功能的应用,特别是在回测阶段,我们需要不断更改参数因子、更换交易策略以应对当前的市场。因此创建完整的、功能键全的GUI用户界面至关重要。我们在【搭...
  • 数据库为:mongodb 数据获取包为:tushare(但是获取市净率需要... 没有积分可引入聚宽,米筐等一系列量化平台的接口 代码为: df = ts.get_hist_data('hs300',start="2017-11-21",end='2017-12-23') #2017...
  • 量化策略入门系列文章是本人学习股票量化笔记,最终输出结果希望是一个可在本地运行的回测框架,包含数据获取,数据处理,策略回测等。 本文主要为了介绍如何利用聚宽(JoinQuant)的数据接口下载金融数据。主要针对量...
  • 聚宽数据JQData中的股票复权方法

    千次阅读 2018-11-29 20:42:46
    进行股票量化回测,面临的第一个坑就是数据坑——首先你得有数据,才能进行下一步工作。 在股票数据坑中,有一个很大的坑叫做股票的复权价格。   如果一个股票公告说进行分红、配股或者送转,那么这只股票就被...
  • 聚宽JQData说明书

    千次阅读 2019-02-19 19:50:26
    JQData是聚宽数据团队专门为金融机构、学术团体和量化研究者们提供的本地量化金融数据服务。使用JQData,可快速查看和计算金融数据,无障碍解决本地、Web、金融终端调用数据的需求。历经3年沉淀,15万宽客及数百家...
  • 聚宽API学习

    千次阅读 2019-01-03 19:24:01
    获取所有交易日 get_all_trade_days 获取所有交易日, 不需要传入参数, ...g.t 回测运行的天数; g.ATD 记录脚本运行的天数 g.tc 设置调仓参数 g.lag 用过去多少期的财报回归 g.N 需要前多山天的数据 g.factors 选取...
  • 目前聚宽已支持国内外50多家高校的教学使用,包括『本地数据支持』、『投研环境支持』、『线上线下量化课程』、『量化大赛』、『工作机会』等多元化的量化生态服务,助力学生们步步进阶。 01 | 前言 近年来,...
  • 岁月不居,时节如流,聚宽量化交易平台与大家共度了一个不平凡的2019年,在这一年里,虽然投资环境波云诡谲,难以捉摸,但是在聚宽依然有许许多多的用户做出了优秀的研究,并无私分享。 因此,我们会评选分享达人与...
  • 我找了个参照标准:在聚宽上开通了个账号,按入门教程写了个策略:2016-2018年每个交易日买入100股平安银行(000001),回测结果如下: 现在用pyalgotrade来实现一下这个策略。先用tushare下载平安银行及沪深300指数的...
  • 聚宽下单、函数、API

    千次阅读 2019-02-19 20:00:05
    security 标的代码,数据类型要求是字符串,想知道 基金、期货、指数的代码都是什么,可以在这里看聚宽数据,比如聚宽数据-向下滚动页面-点击指数数据,可以看到各指数的代码。特别的是股票代码目前没有页面,但只需...
  • 做量化交易的朋友都知道回测的重要性,回测结果是衡量一个量化交易策略是否靠谱的重要依据。回测平台会按历史行情数据模拟成交,并将回测结果汇总成报告。 在很多时候,仅有一份回测的最终结果是不够的。比如说当...
  • zipline是美国著名的量化策略平台quantopian开发和维护的量化交易库,并且quantopian量化平台的回测引擎也是基于zipline的,除此之外,像国内比较有名的三大矿聚宽(JointQuant)、米筐(RiceQuant)、优矿的回测引擎也...
  • 框架、库 CCXT ... 在线量化平台 ...是个平台 数字货币实测和回测有限制 ...此外还有 Quantopian(国外)、BigQuant、聚宽、万矿、优矿、米筐、掘金 catalyst 加密货币算法交易库,可以用它编写交易策略,并进行日线
  • Prophet() m.fit(df) future_time = m.make_future_dataframe(periods=365) forecast = m.predict(future_time) fig1 = m.plot(forecast) fig2 = m.plot_components(forecast) 运行fbprophet后对以下代码进行回测:...

空空如也

空空如也

1 2 3 4 5 ... 9
收藏数 167
精华内容 66
关键字:

聚宽本地回测