精华内容
下载资源
问答
  • 期货交易策略源代码
    万次阅读 多人点赞
    2020-11-16 10:32:44

    1.双均线策略(期货)

    双均线策略是简单移动平均线策略的加强版。移动平均线目的是过滤掉时间序列中的高频扰动,保留有用的低频趋势。它以滞后性的代价获得了平滑性,比如,在一轮牛市行情后,只有当价格出现大幅度的回撤之后才会在移动平均线上有所体现,而对于投资者而言则大大增加了交易成本。如果使用双均线策略,就可以在考虑长周期趋势的同时,兼顾比较敏感的小周期趋势,无疑是解决简单移动平均线滞后性弱点的一项有效方法。

    双均线策略源代码:https://www.myquant.cn/docs/python_strategyies/153

    2.菲阿里四价(期货)

    昨天高点、昨天低点、昨日收盘价、今天开盘价,可并称为菲阿里四价。它由日本期货冠军菲阿里实盘采用的主要突破交易参照系。此外,因菲阿里主观心智交易的模式,决定了其在实际交易中还大量结合并运用了“阻溢线”的方式,即阻力线、支撑线。

    主要特点:日内交易策略,收盘平仓;菲阿里四价指昨日高点、昨日低点、昨日收盘、今日开盘;上轨=昨日高点;下轨=昨日低点;当价格突破上轨,买入开仓;当价格跌穿下轨,卖出开仓。

    菲阿里四价策略源代码:https://www.myquant.cn/docs/python_strategyies/426

    3.布林线均值回归(期货)

    BOLL指标是美国股市分析家约翰·布林根据统计学中的标准差原理设计出来的一种非常简单实用的技术分析指标。一般而言,股价的运动总是围绕某一价值中枢(如均线、成本线等)在一定的范围内变动,布林线指标正是在上述条件的基础上,引进了“股价通道”的概念,其认为股价通道的宽窄随着股价波动幅度的大小而变化,而且股价通道又具有变异性,它会随着股价的变化而自动调整。由于之前大部分交易策略都是选股或者趋势追踪的择时,所以基于这一指标我们设计了一个均值回归的交易策略。

    布林线均值回归策略源代码:https://www.myquant.cn/docs/python_strategyies/428

    4.网格交易(期货)

    网格交易是利用市场震荡行情获利的一种主动交易策略,其本质是利用投资标的在一段震荡行情中价格在网格区间内的反复运动以进行加仓减仓的操作以达到投资收益最大化的目的。通俗点讲就是根据建立不同数量.不同大小的网格,在突破网格的时候建仓,回归网格的时候减仓,力求能够捕捉到价格的震荡变化趋势,达到盈利的目的。

    网格交易策略源代码:https://www.myquant.cn/docs/python_strategyies/104

    5.跨期套利(期货)

    跨期套利就是在同一期货品种的不同月份合约上建立数量相等、方向相反的交易头寸,最后以对冲或交割方式结束交易、获得收益的方式。最简单的跨期套利就是买入近期的期货品种,卖出远期的期货品种。

    跨期套利策略源代码:https://www.myquant.cn/docs/python_strategyies/107

    6.跨品种套利(期货)

    跨品种套利是指利用两种不同的,但相互关联的商品之间的合约价格差异进行套利交易,即买入某一交割月份的某种商品合约,同时卖出另一相同交割月份、相互关联的商品合约,以期在有利时机同时将这两个合约对冲平仓获利。

    跨品种套利的主导思想是寻找两种或多种不同,但具有一定相关性的商品间的相对稳定关系(差值、比值或其他),在其脱离正常轨道时采取相关反向操作以获取利润。根据套利商品之间的关系,跨品种套利可分为相关商品套利和产业链跨品种套利两种类型。

    跨品种套利策略源代码:https://www.myquant.cn/docs/python_strategyies/106

    7.海龟交易法(期货)

    海龟交易法则属于趋势交易,首先建立唐奇安通道(下文会具体解释),即确定上突破线和下突破线,如果价格突破上线,则做多,如果价格突破下线就平仓或做空。

    海龟交易法策略源码:https://www.myquant.cn/docs/python_strategyies/110

    8.Dual Thrust(期货)

    Dual Thrust是一个趋势跟踪系统,由Michael Chalek在20世纪80年代开发,曾被Future Thruth杂志评为最赚钱的策略之一。Dual Thrust系统具有简单易用、适用度广的特点,其思路简单、参数很少,配合不同的参数、止盈止损和仓位管理,可以为投资者带来长期稳定的收益,被投资者广泛应用于股票、货币、贵金属、债券、能源及股指期货市场等。

    Dual Thrust策略源码:https://www.myquant.cn/docs/python_strategyies/424

    9.R-Breaker(期货)

    R-Breaker是一种短线日内交易策略,该策略已经在市场上存活了二十年之久,尤其当指数波动较大时,该策略表现越好,根据S&P至2011年底的统计,R-Break也多次名列前十,由于进入榜单的交易系统业绩并不稳定,尤其是一年业绩榜单,时常会发生变化,因此模型的稳定性和一致性其实比短期排名更加关键,杂志给出了长期来看一致性最好的十大交易模型,其中就包括 R-Breaker 等模型,它们的业绩不一定总是能排进前十名的榜单,但长期以来具有较高的一致性。

    R-Breaker策略源码:https://www.myquant.cn/docs/python_strategyies/425

    10.做市商交易(期货)

    做市商的主要利润来自于双向报价的买卖价差。因而,做市商需要计算期权的理论价格,在大量买入和卖出交易中,逐渐积累每笔交易价格和理论价格的差价,并根据持仓头寸特征,动态调整价差。由于做市商以被动成交为主,因而在一些对手方持续大量单边交易的情况下,做市商可能面临损失。

    做市商交易策略源码:https://www.myquant.cn/docs/python_strategyies/109

    11.alpha对冲(期货)

    投资者在市场交易中面临着系统性风险(即贝塔或Beta、β风险)和非系统性风险(即阿尔法或Alpha、α风险),通过对系统性风险进行度量并将其分离,从而获取超额绝对收益(即阿尔法收益)的策略组合,即为阿尔法策略。

    alpha对冲策略源代码:https://www.myquant.cn/docs/python_strategyies/101

     

    更多相关内容
  • 博文《Python量化交易策略及回测系统》详细的介绍了Python量化交易策略编写的全过程,包括: 1、数据的获取 2、量化交易策略回测系统的编写 3、量化交易策略的设计 4、使用量化交易策略及回测系统对多个股票进行回测...
  • 课程内容从常用的C++开发技术讲起,到期货tick数据采集,k线生成,下单及策略撰写,从0到1实现一套可实盘的量化交易系统。 课程注重实战,学员上课后,可以达到:日常进行的数据收集,撰写量化策略,实盘交易。   ...
  • 主要功能:接收市场行情数据,生成K线数据并保存至数据库根据交易策略,寻找获利机会并做出开仓/平仓,止损/止盈等决策根据决策自动执行报,撤单操作支持上期CTP交易接口支持多种数据用于盘后复盘支持美式/欧式...
  • 期货CTA策略
    from math import ceil, floor
    
    from tqz_strategy.template import CtaTemplate
    from public_module.object import BarData, RenkoData
    from public_module.constant import RenkoDirection
    from public_module.utility import BarGenerator
    
    
    """
    背驰 or 转势 离场
    """
    class TQZFutureRenkoWaveStrategy(CtaTemplate):
        """
        future strategy(1h period). 废弃
        """
        author = "tqz"
    
        # --- param part ---
        fast_window = 30
        slow_window = 250
    
        lots_size = 0
        renko_size = 0
    
        min_tick_price_flow = 0
    
        parameters = ["fast_window", "slow_window", "lots_size", "renko_size", "min_tick_price_flow"]
    
        # --- var part ---
        fast_ma_value = 0.0
        slow_ma_value = 0.0
    
        variables = ["fast_ma_value", "slow_ma_value"]
    
        def __init__(self, cta_engine, strategy_name, vt_symbol, setting):
            """"""
            super().__init__(cta_engine, strategy_name, vt_symbol, setting)
            self.bg = BarGenerator(self.on_bar)
    
            self.bar_close_prices = []
            self.renko_list = []
    
            self.high_renko_prices = []
            self.low_renko_prices = []
    
            self.first_bar_close_price = 0
    
    
        def on_bar(self, bar: BarData):
            """
            Callback of new bar data update.
            """
    
            # 1. update self.bars_close_prices & update params.
            if self.__update_params_ok(new_bar=bar) is False:
                return
    
            # 2. trend direction.
            long_direction = self.fast_ma_value > self.slow_ma_value
            short_direction = self.fast_ma_value < self.slow_ma_value
    
            # 3. modify postion.
            last_renko0 = self.renko_list[-1]
            last_renko1 = self.renko_list[-2]
            if long_direction:
                if self.pos == 0:
                    if last_renko1.renko_direction == RenkoDirection.SHORT and last_renko0.renko_direction == RenkoDirection.LONG:
                        self.set_position(pos=self.lots_size)
    
                elif self.pos < 0:
                    if last_renko1.renko_direction == RenkoDirection.SHORT and last_renko0.renko_direction == RenkoDirection.LONG:
                        self.set_position(pos=self.lots_size)
                    else:
                        self.set_position(pos=0)
    
                elif self.pos > 0:
                    if last_renko1.renko_direction == RenkoDirection.LONG and last_renko0.renko_direction == RenkoDirection.SHORT:
                        if len(self.high_renko_prices) >= 2:
                            if self.high_renko_prices[-1] < self.high_renko_prices[-2]:
                                self.set_position(pos=0)
    
            elif short_direction:
                if self.pos == 0:
                    if last_renko1.renko_direction == RenkoDirection.LONG and last_renko0.renko_direction == RenkoDirection.SHORT:
                        self.set_position(pos=-1 * self.lots_size)
    
                elif self.pos > 0:
                    if last_renko1.renko_direction == RenkoDirection.LONG and last_renko0.renko_direction == RenkoDirection.SHORT:
                        self.set_position(pos=-1 * self.lots_size)
                    else:
                        self.set_position(pos=0)
    
                elif self.pos < 0:
                    if last_renko1.renko_direction == RenkoDirection.SHORT and last_renko0.renko_direction == RenkoDirection.LONG:
                        if len(self.low_renko_prices) >= 2:
                            if self.low_renko_prices[-1] > self.low_renko_prices[-2]:
                                self.set_position(pos=0)
    
    
        def __update_params_ok(self, new_bar: BarData) -> bool:
            if len(self.bar_close_prices) < self.slow_window:
                self.bar_close_prices.append(new_bar.close_price)
                self.__update_renko_list(new_bar=new_bar)
                return False
    
            # update self.bar_close_prices
            self.bar_close_prices.remove(self.bar_close_prices[0])
            self.bar_close_prices.append(new_bar.close_price)
    
            # update fast_ma & slow_ma
            self.fast_ma_value = sum(self.bar_close_prices[-self.fast_window:]) / self.fast_window
            self.slow_ma_value = sum(self.bar_close_prices[-self.slow_window:]) / self.slow_window
    
            # update renko_list
            self.__update_renko_list(new_bar=new_bar)
    
            return True
    
        def __update_renko_list(self, new_bar: BarData):
            if len(self.renko_list) is 0:
                if self.first_bar_close_price is 0:  # init strategy.
                    self.first_bar_close_price = new_bar.close_price
                else:
                    """ 判断是否满足生成第一个renko的条件 """
                    ticks_diff = (new_bar.close_price - self.first_bar_close_price) / self.min_tick_price_flow
                    if ticks_diff > self.renko_size:
                        """ 更新第一个renko为红色 """
                        renko_counts = floor(ticks_diff / self.renko_size)
                        renko_price = self.first_bar_close_price + renko_counts * self.renko_size * self.min_tick_price_flow
                        self.renko_list.append(RenkoData(renko_price=renko_price, renko_direction=RenkoDirection.LONG, renko_value=renko_counts))
    
                    elif ticks_diff < -1 * self.renko_size:
                        """ 更新第一个renko为绿色 """
                        renko_counts = ceil(ticks_diff / self.renko_size)
                        renko_price = self.first_bar_close_price + renko_counts * self.renko_size * self.min_tick_price_flow
                        self.renko_list.append(RenkoData(renko_price=renko_price, renko_direction=RenkoDirection.SHORT, renko_value=renko_counts))
    
            else:
                last_renko = self.renko_list[-1]
                ticks_diff = (new_bar.close_price - last_renko.renko_price) / self.min_tick_price_flow
                if last_renko.renko_direction == RenkoDirection.LONG:  # 当前为红砖
                    if ticks_diff > self.renko_size:
                        """ 新增红砖 """
                        renko_counts = floor(ticks_diff / self.renko_size)
                        renko_price = last_renko.renko_price + renko_counts * self.renko_size * self.min_tick_price_flow
                        self.renko_list.append(RenkoData(renko_price=renko_price, renko_direction=RenkoDirection.LONG, renko_value=last_renko.renko_value+renko_counts))
    
                    elif ticks_diff < -2 * self.renko_size:
                        """ 新增绿砖 """
                        renko_counts = ceil(ticks_diff / self.renko_size)
                        renko_price = last_renko.renko_price + renko_counts * self.renko_size * self.min_tick_price_flow
                        self.renko_list.append(RenkoData(renko_price=renko_price, renko_direction=RenkoDirection.SHORT, renko_value=renko_counts+1))
    
                        if self.pos > 0:
                            self.high_renko_prices.append(renko_price)
    
                elif last_renko.renko_direction == RenkoDirection.SHORT:  # 当前为绿砖
                    if ticks_diff < -1 * self.renko_size:
                        """ 新增绿砖 """
                        renko_counts = ceil(ticks_diff / self.renko_size)
                        renko_price = last_renko.renko_price + renko_counts * self.renko_size * self.min_tick_price_flow
                        self.renko_list.append(RenkoData(renko_price=renko_price, renko_direction=RenkoDirection.SHORT, renko_value=last_renko.renko_value+renko_counts))
    
                    elif ticks_diff > 2 * self.renko_size:
                        """ 新增红砖 """
                        renko_counts = floor(ticks_diff / self.renko_size)
                        renko_price = last_renko.renko_price + renko_counts * self.renko_size * self.min_tick_price_flow
                        self.renko_list.append(RenkoData(renko_price=renko_price, renko_direction=RenkoDirection.LONG, renko_value=renko_counts-1))
    
                        if self.pos < 0:
                            self.low_renko_prices.append(renko_price)
    
        def set_position(self, pos: int):
            if (self.pos > 0 and pos < 0) or (self.pos < 0 and pos > 0) or (pos is 0):
                self.high_renko_prices = []
                self.low_renko_prices = []
    
            self.pos = pos
    
        def on_init(self):
            """
            Callback when strategy is inited.
            """
            self.write_log(msg=f'strategy_name: {self.strategy_name}, fast_window: {self.fast_window}, slow_window: {self.slow_window}, lots_size: {self.lots_size}, renko_size: {self.renko_size}, min_tick_price_flow: {self.min_tick_price_flow} on_init.')
            pass
    
        def on_start(self):
            """
            Callback when strategy is started.
            """
            self.write_log(msg=f'strategy_name: {self.strategy_name} on_start.')
            pass
    
        def on_stop(self):
            """
            Callback when strategy is stopped.
            """
    
            self.write_log(msg=f'strategy_name: {self.strategy_name} on_stop.')
    

    展开全文
  • TB 开拓者 通用15分钟原码程序化交易策略期货自动交易 通用15分钟原码程序化交易策略期货自动交易 通用15分钟原码程序化交易策略期货自动交易
  • 策略说明:模拟交易产生一次亏损后才启动真实下单交易。系统要素:1、两条指数平均线2、RSI指标3、唐奇安通道入场条件:1、模拟交易产生一次亏损、短期均线在长期均线之上、RSI低于超买值、创新高,则开多单2、模拟交易...

    策略说明:

    模拟交易产生一次亏损后才启动真实下单交易。

    系统要素:

    1、两条指数平均线

    2、RSI指标

    3、唐奇安通道

    入场条件:

    1、模拟交易产生一次亏损、短期均线在长期均线之上、RSI低于超买值、创新高,则开多单

    2、模拟交易产生一次亏损、短期均线在长期均线之下、RSI高于超卖值、创新低,则开空单

    出场条件:

    1、持有多单时小于唐奇安通道下轨,平多单

    2、持有空单时大于唐奇安通道上轨,平空单

    做多代码及解读如下:

    Params

    Numeric FastLength(9); // 声明数值参数FastLength,初值9,即短期指数平均线参数。//

    Numeric SlowLength(19); // 声明数值参数SlowLength,初值19,即长期指数平均线参数。//

    Numeric Length(9); // 声明数值参数Length,初值9,即RSI参数。//

    Numeric OverSold(30); // 声明数值参数OverSold,初值30,即超卖。//

    Numeric OverBought(70); // 声明数值参数OverBought,初值70,即超买。//

    Numeric Lots(0); // 声明数值参数Lots,初值0,即交易手数设置。//

    Vars

    NumericSeries AvgValue1; // 声明数值序列变量AvgValue1,即短期指数平均线 。//

    NumericSeries AvgValue2; // 声明数值序列变量AvgValue2,即长期指数平均线。//

    NumericSeries NetChgAvg(0);//声明数值序列变量NetChgAvg,初值0。//

    NumericSeries TotChgAvg(0);//声明数值序列变量TotChgAvg,初值0.//

    Numeric SF(0);//声明数值变量SF,初值0.//

    Numeric Change(0); //声明数值变量Change,初值0.//

    Numeric ChgRatio(0);//声明数值变量ChgRatio,初值0.//

    NumericSeries RSIValue; // 声明数值序列变量RSIValue,即RSI指标。//

    NumericSeries ExitHiBand(0); // 声明数值序列变量ExitHiBand,初值0,唐奇安通道上轨。//

    NumericSeries ExitLoBand(0); //声明数值序列变量ExitLoBand,初值0, 唐奇安通道下轨。//

    NumericSeries myEntryPrice(0); //声明数值序列变量myEntryPrice,初值0, 进场价格。//

    NumericSeries myExitPrice(0); // 声明数值序列变量myExitPrice,初值0,出场价格。//

    NumericSeries myProfit(0); // 声明数值序列变量myProfit,初值0,即利润。//

    NumericSeries myPosition(0); // 声明数值序列变量myPosition,初值0,即多空标志。//

    Begin

    If(!CallAuctionFilter()) Return;// 集合竞价和小节休息过滤。//

    AvgValue1 = Xaverage(Close,FastLength);// 计算短期指数平均线,即把收盘价与周期9返回函数Xaverage求值。//

    AvgValue2 = Xaverage(Close,SlowLength);//同理,计算长期指数平均线参数。//

    // 计算RSI。//

    If(CurrentBar <= Length - 1)//假如当前索引k线数位值小于等于周期8(9-1)的。//

    {

    NetChgAvg = (Close - Close[Length])/Length;//代入相应数值计算,即得NetChgAvg = (close - close[9])/ 9的。//

    TotChgAvg = Average(Abs(Close - Close[1]),Length);//先算绝对值函数Abs里的,再把绝对值与周期9返回均值函数Average求均值,最后赋值给变量TotChgAvg。//

    }Else//就是k线数位值大于周期8的。//

    {

    SF = 1/Length;//代入相应数值,即SF= 1/9 了.//

    Change = Close - Close[1];//同理,代入当期k线收盘价与前一k线收盘价即可。//

    NetChgAvg = NetChgAvg[1] + SF*(Change - NetChgAvg[1]);//这里也是代入上边求得的相应数值即可。//

    TotChgAvg = TotChgAvg[1] + SF*(Abs(Change) - TotChgAvg[1]); //同上解读。//

    }

    If(TotChgAvg <> 0)//假如变量TotChgAvg不等于0.//

    {

    ChgRatio = NetChgAvg/TotChgAvg;//则两变量相除了。//

    }Else//等于0的。//

    {

    ChgRatio = 0;//变量ChgRatio=0了。//

    }

    RSIValue = 50*(ChgRatio + 1);//指标RSI的计算结果。//

    ExitHiBand = Highest(High,20); // 唐奇安通道上轨。//

    ExitLoBand = Lowest(Low,20);// 唐奇安通道下轨。//

    If(myPosition == 1 And myPosition[1] == 1 and Low <= ExitLoBand[1])// 持有多单时,下破唐奇安通道下轨,平多单。//

    {

    myExitPrice = Min(Open,ExitLoBand[1]);//出场价的计算,开盘价与前一个唐奇安通道下轨的比较,取较小值。//

    Sell(0,myExitPrice);//平仓。//

    myProfit = myExitPrice - MyEntryPrice;//利润算法。//

    myPosition = 0;//持仓多空标志myPosition = 0.//

    }

    If(myPosition == 0 And myPosition[1] == 0 And AvgValue1[1] > AvgValue2[1] And RSIValue[1] < OverBought and High >= High[1])// 模拟交易产生一次亏损、短期均线在长期均线之上、RSI低于超买值、创新高,则开多单。//

    {

    myEntryPrice = Max(Open,High[1]);//进场价计算,即开盘价与前一个最高价的比较,取较大值。//

    myPosition = 1;//持仓多空标志myPosition = 1.//

    If(myProfit < 0) Buy(Lots,myEntryPrice);//假如利润myProfit <0的,以进场价开仓。//

    }

    End

    做空代码及结果如下:

    Params

    Numeric FastLength(9);

    Numeric SlowLength(19);

    Numeric Length(9);

    Numeric OverSold(30);

    Numeric OverBought(70);

    Numeric Lots(0);

    Vars

    NumericSeries AvgValue1;

    NumericSeries AvgValue2;

    NumericSeries NetChgAvg(0);

    NumericSeries TotChgAvg(0);

    Numeric SF(0);

    Numeric Change(0);

    Numeric ChgRatio(0);

    NumericSeries RSIValue;

    NumericSeries ExitHiBand(0);

    NumericSeries ExitLoBand(0);

    NumericSeries myEntryPrice(0);

    NumericSeries myExitPrice(0);

    NumericSeries myProfit(0);

    NumericSeries myPosition(0);

    Begin

    If(!CallAuctionFilter()) Return;

    AvgValue1 = Xaverage(Close,FastLength);

    AvgValue2 = Xaverage(Close,SlowLength);

    If(CurrentBar <= Length - 1)

    {

    NetChgAvg = (Close - Close[Length])/Length;

    TotChgAvg = Average(Abs(Close - Close[1]),Length);

    }Else

    {

    SF = 1/Length;

    Change = Close - Close[1];

    NetChgAvg = NetChgAvg[1] + SF*(Change - NetChgAvg[1]);

    TotChgAvg = TotChgAvg[1] + SF*(Abs(Change) - TotChgAvg[1]);

    }

    If(TotChgAvg <> 0)

    {

    ChgRatio = NetChgAvg/TotChgAvg;

    }Else

    {

    ChgRatio = 0;

    }

    RSIValue = 50*(ChgRatio + 1);

    ExitHiBand = Highest(High,20);

    ExitLoBand = Lowest(Low,20);

    If(myPosition == -1 And myPosition[1] == -1 and High >= ExitHiBand[1])

    {

    myExitPrice = Max(Open,ExitHiBand[1]);

    BuyToCover(0,myExitPrice);

    myProfit = myEntryPrice - MyExitPrice;

    myPosition = 0;

    }

    If(myPosition == 0 And myPosition[1] == 0 And AvgValue1[1] < AvgValue2[1] And RSIValue[1] > OverSold and Low <= Low[1])

    {

    myEntryPrice = Min(Open,Low[1]);

    myPosition = -1;

    If(myProfit < 0) SellShort(Lots,myEntryPrice);

    }

    End

    展开全文
  • 阿布量化系统源代码 abupy目录 阿布量化使用教程 abupy_lecture目录 阿布量化非编程界面操作 abupy_ui目录 《量化交易之路》示例代码 ipython/python目录 《机器学习之路》示例代码 ...
  • 将策略研究过程带到短期,中期交易策略中,提高盈利机会。课程使用数据来源于两个早期课程:股票数据下载课程 https://edu.csdn.net/course/detail/24720 ?期货tick数据收集整理课程 ...
  • 将策略研究过程带到短期,中期交易策略中,提高盈利机会。课程使用数据来源于两个早期课程:股票数据下载课程 https://edu.csdn.net/course/detail/24720  期货tick数据收集整理课程 ...
  • 量化投资可转债策略--源代码

    千次阅读 2021-03-10 17:17:11
    海龟交易策略是一套非常完整的趋势跟随型的自动化交易策略。这个复杂的策略在入场条件、仓位控制、资金管理、止损止盈等各个环节,都进行了详细的设计,这基本上可以作为复杂交易策略设计和开发的模板。 海龟交易...

    一、十大量化投资策略(含源码)

    量化投资策略是利用量化的方法,进行金融市场的分析、判断和交易的策略、算法的总称。著名的量化投资策略有以下10种(注:策略源码模板不能直接用于实盘交易,仅供探讨交流)

    01、海龟交易策略

    海龟交易策略是一套非常完整的趋势跟随型的自动化交易策略。这个复杂的策略在入场条件、仓位控制、资金管理、止损止盈等各个环节,都进行了详细的设计,这基本上可以作为复杂交易策略设计和开发的模板。

    海龟交易策略源码:https://www.myquant.cn/docs/python_strategyies/110

    02、阿尔法策略

    阿尔法的概念来自于二十世纪中叶,经过学者的统计,当时约75%的股票型基金经理构建的投资组合无法跑赢根据市值大小构建的简单组合或是指数,属于传统的基本面分析策略。

    在期指市场上做空,在股票市场上构建拟合300指数的成份股,赚取其中的价差,这种被动型的套利就是贝塔套利。

    阿尔法策略源代码:https://www.myquant.cn/docs/python_strategyies/101

    03、多因子选股

    多因子模型是量化选股中最重要的一类模型,基本思想是找到某些和收益率最相关的指标,并根据该指标,构建一个股票组合,期望该组合在未来的一段时间跑赢或跑输指数。如果跑赢,则可以做多该组合,同时做空期指,赚取正向阿尔法收益;如果是跑输,则可以组多期指,融券做空该组合,赚取反向阿尔法收益。多因子模型的关键是找到因子与收益率之间的关联性。

    多因子选股策略源码:https://www.myquant.cn/docs/python_strategyies/103

    04、双均线策略

    双均线策略,通过建立m天移动平均线,n天移动平均线,则两条均线必有交点。若m>n,n天平均线“上穿越”m天均线则为买入点,反之为卖出点。该策略基于不同天数均线的交叉点,抓住股票的强势和弱势时刻,进行交易。

    双均线策略中,如果两根均线的周期接近,比如5日线,10日线,这种非常容易缠绕,不停的产生买点卖点,会有大量的无效交易,交易费用很高。如果两根均线的周期差距较大,比如5日线,60日线,这种交易周期很长,趋势性已经不明显了,趋势转变以后很长时间才会出现买卖点。也就是说可能会造成很大的亏损。所以两个参数选择的很重要,趋势性越强的品种,均线策略越有效。

    双均线策略源码:https://www.myquant.cn/docs/python_strategyies/153

    05、行业轮动

    行业轮动是利用市场趋势获利的一种主动交易策略其本质是利用不同投资品种强势时间的错位对行业品种进行切换以达到投资收益最大化的目的。

    行业轮动策略源码:https://www.myquant.cn/docs/python_strategyies/111

    06、跨品种套利

    跨品种套利指的是利用两种不同的、但相关联的指数期货产品之间的价差进行交易。这两种指数之间具有相互替代性或受同一供求因素制约。跨品种套利的交易形式是同时买进和卖出相同交割月份但不同种类的股指期货合约。主要有相关商品间套利和原料与成品之间套利。

    跨品种套利的主要作用一是帮助扭曲的市场价格回复到正常水平;二是增强市场的流动性。

    跨品种套利策略源码:https://www.myquant.cn/docs/python_strategyies/106

    07、指数增强

    增强型指数投资由于不同基金管理人描述其指数增强型产品的投资目的不尽相同,增强型指数投资并无统一模式,唯一共同点在于他们都希望能够提供高于标的指数回报水平的投资业绩。为使指数化投资名副其实,基金经理试图尽可能保持标的指数的各种特征。

    指数增强策略源码:https://www.myquant.cn/docs/python_strategyies/105

    08、网格交易

    网格交易是利用市场震荡行情获利的一种主动交易策略,其本质是利用投资标的在一段震荡行情中价格在网格区间内的反复运动以进行加仓减仓的操作以达到投资收益最大化的目的。通俗点讲就是根据建立不同数量.不同大小的网格,在突破网格的时候建仓,回归网格的时候减仓,力求能够捕捉到价格的震荡变化趋势,达到盈利的目的。

    网格交易策略源码:https://www.myquant.cn/docs/python_strategyies/104

    09、跨期套利

    跨期套利是套利交易中最普遍的一种,是股指期货的跨期套利(Calendar Spread Arbitrage)即为在同一交易所进行同一指数、但不同交割月份的套利活动。

    跨期套利策略源码:https://www.myquant.cn/docs/python_strategyies/107

    10、高频交易策略

    高频交易是指从那些人们无法利用的极为短暂的市场变化中寻求获利的计算机化交易,比如,某种证券买入价和卖出价差价的微小变化,或者某只股票在不同交易所之间的微小价差。这种交易的速度如此之快,以至于有些交易机构将自己的“服务器群组”安置到了离交易所的计算机很近的地方,以缩短交易指令通过光缆以光速旅行的距离。(该策略源码模板暂无)

     

    二、可转债量化交易方法

    1、“ 面值- 高价 折扣 法”  (安道全. 可转债投资魔法书(第2版) )

             -最简单的策略,平均年化收益超过10%,但:不适合投机者,不适合大资金(超过500万一般不建议)

            面值一般为100, 折扣以9折为例,则降低到期间最高价的0.9倍,且大于130,就卖出。

        IF  Price <=100  Then

               OP_Buy

        IF  Price >=130  && Price <= Max_period * DISCOUNT   Then

                     OP_Sell

        Else

                  No_OP;

    中间可转债的选择策略:

         DISCOUNT = 0.9

         Max_period  =       Max(0,Now ) 

        #Line_1                   # Line_2               # Line_3   

    2、三条线策略   (根据“ 到期安全价”、“ 回 售”、“ 面值” 三个 价格计算)

    基本 公式 如下:

    (1) 到期 安 全价( 又名 到期 价值)= 到期 赎回 价( 含 最后 1 年 利息)+ 除 最后 1 年 外 所有 未付 利息 之和 × 80%。 (2) 到期 收益率( 税后 单利)+= 到期 价值 ÷ 当 前转 债 价格- 100% (3) 到期 年 化( 年 化 税后 单利)= 到期 收益率 ÷ 剩余 年=( 到期 价值 ÷ 当 前转 债 价格- 100%) ÷ 剩余 年

    根据上述三个价格,灵活确定    建仓线 、 加 仓 线、 重 仓 线 。这个就是买入策略。

    仓位策略:

        根据个人情况,通常采取:   安全待机法:偏重仓线,3:2:5; 安全长持法:3:4:3。具体根据自己情况,但一般不采取一次性建仓。

     

    安全选债策略:

    •  大于120甚至110,一般大于115的不要选
    •  没有 回 售 的 大 转 债不选
    • 存量太小,少于1亿元的不选

    •  刚上市的, 没有 到 转 股 期 的, 除非 特别 看好, 同时 到期 收益率 在 3% 甚至 5% 以上 的, 暂时 不妨 等一等。

    •  PB 低于 1 不选   (由于不能下调转股价)

    •  

    展开全文
  • 将策略研究过程带到短期,中期交易策略中,提高盈利机会。课程使用数据来源于两个早期课程:股票数据下载课程 https://edu.csdn.net/course/detail/24720 ?期货tick数据收集整理课程 ...
  • 横盘突破 较易实现量化的形态突破:分形、窄幅横盘突破、各种K线组合、双底双顶、缠论三买三卖; 较难实现量化的形态突破:趋势线、圆弧顶底、旗形...横盘突破的交易策略,充分体现了波动性循环的价格波动规律。
  • 声明:本文策略源码均来自掘金量化示例策略库,仅供参考! 一、股票策略 1.多因子选股 # coding=utf-8 from __future__ import print_function, absolute_import, unicode_literals import numpy as np from...
  • 刚刚入门量化交易,需要一个基础的源代码来学习</p>
  • 我们还提供: 用于说明样本外回测的源代码以及说明; 大约 2,000 个参考书目; 以及 900 多个词汇表、首字母缩略词和数学定义。 该演示文稿旨在具有描述性和教学性,并且对金融从业人员、交易员、研究人员、学者...
  • 经典的期货量化交易策略大全

    千次阅读 2021-12-28 09:30:00
    1.双均线策略(期货) 双均线策略是简单移动平均线策略的加强版。移动平均线目的是过滤掉时间序列中的高频扰动,保留有用的低频趋势。...双均线策略源代码:https://www.myquant.cn/docs/python_strateg
  • 实现上期技术的行情和交易接口,通过qt mvc 编程模型,实现前后台分离,前台获取用户输入参数,中间层辅助数据传输业务处理,后台专注行情数据分析,交易决策。参数设定后,界面自动退出,后台继续运行算法进行交易...
  • 策略为王源代码(for VS2015)

    热门讨论 2017-08-09 23:10:14
    无论您是有意从事股票/期货的自动交易,还是学习C++编程,读它的源码都是一个很好的开端,我就是这么做的。 策略为王最早的开发环境是VC6。我当时下的代码,最多升级到VS2003。据说能升到VS2005,我没试,但再往上...
  • 取名为幽灵交易者的系统,名字霸气,效果,大家自己测试看看了,照例还是先看策略说明吧:策略说明:模拟交易产生一次亏损后才启动真实下单交易。系统要素:1、两条指数平均线2、RSI指标3、唐奇安通道入场条件:1、模拟...
  • 昨天有空上网看到很多网友都说日内策略很好,而且都比较推荐一本书:《日内交易策略--谷物期货交易实战指南》,所以就下载了电子版的来看了一下,书中讲到他的策略是日内交易的,具体的策略: 从作者所描述的...
  • VNPY系统是一个开源 的量化策略交易系统,学习本课程快速上手量化交易,赚取属于自己的第一桶金! 手把手教课,不错过任何一个细节。 1.环境准备 2.国内期货CTP 3.其他市场交易接口 4.第一个量化策略 5.历史数据回测...
  • 废话不多说,下面就让我们直接来看看海龟交易法则(后面简称“海龟”)的原理~如何选择市场由于“海龟”起源于美国,要求高流动性,因此小编选择了国内商品期货作为交易标的,但是,要注意品种之间的相关性不要太强!...
  • 期货CTP例子源码

    2017-09-01 14:22:38
    CTP开发的例子 做全自动交易的同学 可以学习一下,还是非常有参考意义的 CTP开发的例子 做全自动交易的同学 可以学习一下,还是非常有参考意义的
  • matlab期货代码EliteQuant_Cpp C / C ++高频量化交易和投资平台 平台介绍 EliteQuant是由量化交易者为量化交易者建立的永久免费开源的统一量化交易平台。 它在和上都是双重列出的。 统一一词具有两个特征。 首先,它...
  • 基于天勤sdk和Python开发的期货开源交易系统,主要解决了基于天勤的多策略,多周期,多品种当中的问题。 具体讲解了开源项目当中的用的编程和期货相关的知识。        

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 701
精华内容 280
关键字:

期货交易策略源代码