python股票回测源码_股票量化交易回测框架pyalgotrade源码阅读(一)

PyAlgoTrade是什么呢？

一个股票量化交易的策略回测框架。

而作者的说明如下。

To make it easy to backtest stock trading strategies.

简单的来说，是一个用于验证自己交易策略的框架。

适用以下场景：

我有个前无古人后无来者的想法，我觉得我按照这个想法去买股票稳赚不赔，但是为了稳妥起见，我需要测试一下这个我的这个想法到底用没有用，怎么测试呢？

大概下面两种方法

一：弄个模拟交易的软件，每天按照自己的想法买入卖出，然后看看一个月或者一年后的收益如何。

优点:更贴近现实，至少当下的现实

缺点:测试周期大，数据有限

二：我相信我的这个想法不是针对现在或者未来有用，甚至是在以前应该也是起作用的，那么我可以将历史数据调出来，用于测试，看看在历史行情中收益如何。

优点:数据充分，可以反复测试。

缺点:可能不能贴近现实

而pyalgotrade就是为了提供给使用者基于历史数据回测的框架，即为了让你更好的使用上述的第二种方法。

注:无论怎么测，肯定都有偏差的, 因为都是猜，就像×××，你算好了各种概率，想好了各种策略，但是你能保证的只是你赢钱的概率大一些，而不是必赢，因为在没有欺诈的情况下，未来是不可测，也不能确定的，谁也不能预知未来~吧~

文章目录官方示例

设计模式之观察者模式

源码解析

官方示例

sma_crossover.py文件from pyalgotrade import strategy

from pyalgotrade.technical import ma

from pyalgotrade.technical import cross

class SMACrossOver(strategy.BacktestingStrategy):

def __init__(self, feed, instrument, smaPeriod):

super(SMACrossOver, self).__init__(feed)

self.__instrument = instrument

self.__position = None

# We'll use adjusted close values instead of regular close values.

self.setUseAdjustedValues(True)

self.__prices = feed[instrument].getPriceDataSeries()

self.__sma = ma.SMA(self.__prices, smaPeriod)

def getSMA(self):

return self.__sma

def onEnterCanceled(self, position):

self.__position = None

def onExitOk(self, position):

self.__position = None

def onExitCanceled(self, position):

# If the exit was canceled, re-submit it.

self.__position.exitMarket()

def onBars(self, bars):

# If a position was not opened, check if we should enter a long position.

if self.__position is None:

if cross.cross_above(self.__prices, self.__sma) > 0:

shares = int(self.getBroker().getCash() * 0.9 / bars[self.__instrument].getPrice())

# Enter a buy market order. The order is good till canceled.

self.__position = self.enterLong(self.__instrument, shares, True)

# Check if we have to exit the position.

elif not self.__position.exitActive() and cross.cross_below(self.__prices, self.__sma) > 0:

self.__position.exitMarket()

sma_crossover_sample.pyimport sma_crossover

from pyalgotrade import plotter

from pyalgotrade.tools import yahoofinance

from pyalgotrade.stratanalyzer import sharpe

def main(plot):

instrument = "aapl"

smaPeriod = 163

# Download the bars.

feed = yahoofinance.build_feed([instrument], 2011, 2012, ".")

strat = sma_crossover.SMACrossOver(feed, instrument, smaPeriod)

sharpeRatioAnalyzer = sharpe.SharpeRatio()

strat.attachAnalyzer(sharpeRatioAnalyzer)

if plot:

plt = plotter.StrategyPlotter(strat, True, False, True)

plt.getInstrumentSubplot(instrument).addDataSeries("sma", strat.getSMA())

strat.run()

print "Sharpe ratio: %.2f" % sharpeRatioAnalyzer.getSharpeRatio(0.05)

if plot:

plt.plot()

if __name__ == "__main__":

main(True)

上面的代码主要做一件这样的事。

创建了一个策略，这个策略就是你的想法，这个想法是什么呢？

想法是，当价格高于近163日内的平均价格就买入，低于近163日内的平均价格就卖出(平仓)。

其实还做了其他的事，比如策略分析之类的，但是这篇文章暂时忽略。

设计模式之观察者模式#!/usr/bin/python

#coding:utf8

'''

Observer

'''

class Subject(object):

def __init__(self):

self._observers = []

def attach(self, observer):

if not observer in self._observers:

self._observers.append(observer)

def detach(self, observer):

try:

self._observers.remove(observer)

except ValueError:

pass

def notify(self, modifier=None):

for observer in self._observers:

if modifier != observer:

observer.update(self)

# Example usage

class Data(Subject):

def __init__(self, name=''):

Subject.__init__(self)

self.name = name

self._data = 0

@property

def data(self):

return self._data

@data.setter

def data(self, value):

self._data = value

self.notify()

class HexViewer:

def update(self, subject):

print('HexViewer: Subject %s has data 0x%x' %

(subject.name, subject.data))

class DecimalViewer:

def update(self, subject):

print('DecimalViewer: Subject %s has data %d' %

(subject.name, subject.data))

# Example usage...

def main():

data1 = Data('Data 1')

data2 = Data('Data 2')

view1 = DecimalViewer()

view2 = HexViewer()

data1.attach(view1)

data1.attach(view2)

data2.attach(view2)

data2.attach(view1)

print("Setting Data 1 = 10")

data1.data = 10

print("Setting Data 2 = 15")

data2.data = 15

print("Setting Data 1 = 3")

data1.data = 3

print("Setting Data 2 = 5")

data2.data = 5

print("Detach HexViewer from data1 and data2.")

data1.detach(view2)

data2.detach(view2)

print("Setting Data 1 = 10")

data1.data = 10

print("Setting Data 2 = 15")

data2.data = 15

if __name__ == '__main__':

main()

意图：

定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时, 所有依赖于它的对象都得到通知并被自动更新。

适用性：

当一个抽象模型有两个方面, 其中一个方面依赖于另一方面。将这二者封装在独立的对象中以使它们可以各自独立地改变和复用。

当对一个对象的改变需要同时改变其它对象, 而不知道具体有多少对象有待改变。

当一个对象必须通知其它对象，而它又不能假定其它对象是谁。换言之, 你不希望这些对象是紧密耦合的。

如果你看得懂就略过吧。

上面的代码想做个上面事情呢&