def run_strategy(cash):
instruments = ["000001"]
feeds = tools.build_feed(instruments, 2016, 2018, "histdata")
# 设置手续费
broker_commision = broker.backtesting.TradePercentage(0.0003)
brk = broker.backtesting.Broker(cash, feeds, broker_commision)
myStrategy = MyStrategy(feeds, instruments[0], brk)
retAnalyzer = returns.Returns()
myStrategy.attachAnalyzer(retAnalyzer)
sharpeAnalyzer = sharpe.SharpeRatio()
myStrategy.attachAnalyzer(sharpeAnalyzer)
drawDownAnalyzer = drawdown.DrawDown()
myStrategy.attachAnalyzer(drawDownAnalyzer)
tradesAnalyzer = trades.Trades()
myStrategy.attachAnalyzer(tradesAnalyzer)
# 以沪深300为基准#
instruments300 = ["510300"]
feeds300 = tools.build_feed(instruments300, 2016, 2018, "histdata300")
# 设置手续费
broker_commision = broker.backtesting.TradePercentage(0.0003)
brk = broker.backtesting.Broker(cash, feeds300, broker_commision)
myStrategy300 = MyStrategy(feeds300, instruments300[0], brk)
retAnalyzer300 = returns.Returns()
myStrategy300.attachAnalyzer(retAnalyzer300)
sharpeAnalyzer300 = sharpe.SharpeRatio()
myStrategy300.attachAnalyzer(sharpeAnalyzer300)
drawDownAnalyzer300 = drawdown.DrawDown()
myStrategy300.attachAnalyzer(drawDownAnalyzer300)
tradesAnalyzer300 = trades.Trades()
myStrategy300.attachAnalyzer(tradesAnalyzer300)
plter = plotter.StrategyPlotter(myStrategy)
plter.getOrCreateSubplot("return").addDataSeries("retuens",
retAnalyzer.getReturns())
plter.getOrCreateSubplot("CumReturn").addDataSeries(
"CumReturn", retAnalyzer.getCumulativeReturns())
plter.getOrCreateSubplot("return").addDataSeries(
"retuens300", retAnalyzer300.getReturns())
plter.getOrCreateSubplot("CumReturn").addDataSeries(
"CumReturn300", retAnalyzer300.getCumulativeReturns())
myStrategy.run()
myStrategy300.run()
plter.savePlot("testdata.png")
# print("交易次数:%d" % (tradesAnalyzer.getCount()))
print("策略回测指标")
analyzer((retAnalyzer, sharpeAnalyzer, drawDownAnalyzer, tradesAnalyzer))
print("基准回测指标")
analyzer((retAnalyzer300, sharpeAnalyzer300, drawDownAnalyzer300,
tradesAnalyzer300))
# 计算阿尔法 β 信息比例等值
calculater(retAnalyzer, retAnalyzer300)
return (myStrategy, retAnalyzer, sharpeAnalyzer, drawDownAnalyzer,
tradesAnalyzer)
def analyze_and_draw(feed, instrument, period, cash=10000):
my_strategy = MyStrategy(feed, instrument, period, cash)
# 在执行前添加不同的分析器
ret_analyzer = returns.Returns()
my_strategy.attachAnalyzer(ret_analyzer)
sharpe_ratio_analyzer = sharpe.SharpeRatio()
my_strategy.attachAnalyzer(sharpe_ratio_analyzer)
draw_down_analyzer = drawdown.DrawDown()
my_strategy.attachAnalyzer(draw_down_analyzer)
trades_analyzer = trades.Trades()
my_strategy.attachAnalyzer(trades_analyzer)
# 设置中文等线字体以显示中文
plts.rcParams['font.sans-serif'] = ['DengXian']
plt = plotter.StrategyPlotter(my_strategy, True, False, True)
plt.getInstrumentSubplot(instrument).addDataSeries("SMA",
my_strategy.getSMA())
# 开始执行策略
my_strategy.run()
plt.plot()
# 现金+有价证券
print("最终资产价值 Final portfolio value: ￥%.2f" %
my_strategy.getBroker().getEquity())
print("最终资产价值 Final portfolio value: ￥%.2f" % my_strategy.getResult())
print("累计回报率 Cumulative returns: %.2f %%" %
(ret_analyzer.getCumulativeReturns()[-1] * 100))
print("夏普比率 Sharpe ratio: %.2f" %
(sharpe_ratio_analyzer.getSharpeRatio(0.05)))
print("最大回撤率 Max. drawdown: %.2f %%" %
(draw_down_analyzer.getMaxDrawDown() * 100))
print("最长回撤时间 Longest drawdown duration: %s" %
(draw_down_analyzer.getLongestDrawDownDuration()))
def main():
instrument = "yhoo"
bBandsPeriod = 40
# Download the bars.
# feed = yahoofinance.build_feed([instrument], 2011, 2012, ".")
feed = yahoofeed.Feed()
feed.addBarsFromCSV(instrument, "dat\\yhoo-201x.csv")
strat = BBands(feed, instrument, bBandsPeriod)
sharpeRatioAnalyzer = sharpe.SharpeRatio()
strat.attachAnalyzer(sharpeRatioAnalyzer)
retAnalyzer = returns.Returns()
strat.attachAnalyzer(retAnalyzer)
drawDownAnalyzer = drawdown.DrawDown()
strat.attachAnalyzer(drawDownAnalyzer)
tradesAnalyzer = trades.Trades()
strat.attachAnalyzer(tradesAnalyzer)
# ------
mpl.style.use('seaborn-whitegrid');
plt = plotter.StrategyPlotter(strat, True, True, True)
plt.getInstrumentSubplot(instrument).addDataSeries("upper", strat.getBollingerBands().getUpperBand())
plt.getInstrumentSubplot(instrument).addDataSeries("middle", strat.getBollingerBands().getMiddleBand())
plt.getInstrumentSubplot(instrument).addDataSeries("lower", strat.getBollingerBands().getLowerBand())
strat.run()
plt.plot()
# ==============================
print("最终资产价值 Final portfolio value: $%.2f" % strat.getResult())
print("累计回报率 Cumulative returns: %.2f %%" % (retAnalyzer.getCumulativeReturns()[-1] * 100))
print("夏普比率 Sharpe ratio: %.2f" % (sharpeRatioAnalyzer.getSharpeRatio(0.05)))
print("最大回撤率 Max. drawdown: %.2f %%" % (drawDownAnalyzer.getMaxDrawDown() * 100))
print("最长回撤时间 Longest drawdown duration: %s" % (drawDownAnalyzer.getLongestDrawDownDuration()))
def main():
feed = csvfeed.GenericBarFeed(frequency=Frequency.MINUTE)
feed.addBarsFromCSV("ETH", "sampledata.csv")
# Evaluate the strategy with the feed's bars.
myStrategy = Accumulator(feed, "ETH", buy_offset=0.0017, buy_percent=0.49)
# myStrategy.run()
returnsAnalyzer = returns.Returns()
myStrategy.attachAnalyzer(returnsAnalyzer)
tradesAnalyzer = trades.Trades()
myStrategy.attachAnalyzer(tradesAnalyzer)
plt = plotter.StrategyPlotter(myStrategy)
# Include the SMA in the instrument's subplot to get it displayed along with the closing prices.
plt.getInstrumentSubplot("ETH").addDataSeries("SMA", myStrategy.getSMA())
# Plot the simple returns on each bar.
plt.getOrCreateSubplot("returns").addDataSeries(
"Simple returns", returnsAnalyzer.getReturns())
# Run the strategy.
myStrategy.run()
myStrategy.info("Final portfolio value: $%.2f" % myStrategy.getResult())
# Plot the strategy.
plt.plot()
print("Final portfolio value: $%.2f" % myStrategy.getResult())
def testLong2(self):
strat = self.__createStrategy()
stratAnalyzer = trades.Trades()
strat.attachAnalyzer(stratAnalyzer)
# Enter long
strat.addOrder(buildUTCDateTime(2011, 1, 3, 15, 0),
strat.getBroker().createMarketOrder,
broker.Order.Action.BUY,
TradesAnalyzerTestCase.TestInstrument, 1) # 127.14
# Extend long position
strat.addOrder(buildUTCDateTime(2011, 1, 3, 15, 16),
strat.getBroker().createMarketOrder,
broker.Order.Action.BUY,
TradesAnalyzerTestCase.TestInstrument, 1) # 127.16
# Exit long
strat.addOrder(buildUTCDateTime(2011, 1, 3, 15, 30),
strat.getBroker().createMarketOrder,
broker.Order.Action.SELL,
TradesAnalyzerTestCase.TestInstrument, 2) # 127.2
strat.run()
self.assertTrue(
round(strat.getBroker().getCash(), 2) == round(
1000 + (127.2 - 127.14) + (127.2 - 127.16), 2))
self.assertTrue(stratAnalyzer.getCount() == 1)
self.assertTrue(stratAnalyzer.getEvenCount() == 0)
self.assertTrue(round(stratAnalyzer.getAll().mean(), 2) == 0.1)
self.assertTrue(stratAnalyzer.getProfitableCount() == 1)
self.assertTrue(round(stratAnalyzer.getProfits().mean(), 2) == 0.1)
self.assertTrue(stratAnalyzer.getUnprofitableCount() == 0)
def testShort3(self):
strat = self.__createStrategy()
stratAnalyzer = trades.Trades()
strat.attachAnalyzer(stratAnalyzer)
# Enter short
strat.addOrder(buildUTCDateTime(2011, 1, 3, 15, 0),
strat.getBroker().createMarketOrder,
broker.Order.Action.SELL_SHORT,
TradesAnalyzerTestCase.TestInstrument, 2) # 127.14
# Decrease short position
strat.addOrder(buildUTCDateTime(2011, 1, 3, 15, 16),
strat.getBroker().createMarketOrder,
broker.Order.Action.BUY_TO_COVER,
TradesAnalyzerTestCase.TestInstrument, 1) # 127.16
# Exit short
strat.addOrder(buildUTCDateTime(2011, 1, 3, 15, 30),
strat.getBroker().createMarketOrder,
broker.Order.Action.BUY_TO_COVER,
TradesAnalyzerTestCase.TestInstrument, 1) # 127.2
strat.run()
self.assertTrue(
round(strat.getBroker().getCash(), 2) == round(
1000 + (127.14 - 127.16) + (127.14 - 127.2), 2))
self.assertTrue(stratAnalyzer.getCount() == 1)
self.assertTrue(stratAnalyzer.getEvenCount() == 0)
self.assertTrue(round(stratAnalyzer.getAll().mean(), 2) == -0.08)
self.assertTrue(stratAnalyzer.getUnprofitableCount() == 1)
self.assertTrue(round(stratAnalyzer.getLosses().mean(), 2) == -0.08)
self.assertTrue(stratAnalyzer.getProfitableCount() == 0)
def run_strategy(cash):
# instruments = ["000001"]
# feeds = tools.build_feed(instruments, 2016, 2018, "histdata")
instruments = ["000989"]
feeds = buildFeed(instruments[0], downloadData(instruments[0]))
# 设置手续费, 万分之一
broker_commision = broker.backtesting.TradePercentage(0.0001)
brk = broker.backtesting.Broker(cash, feeds, broker_commision)
myStrategy = MyStrategy(feeds, instruments[0], brk)
retAnalyzer = returns.Returns()
myStrategy.attachAnalyzer(retAnalyzer)
sharpeAnalyzer = sharpe.SharpeRatio()
myStrategy.attachAnalyzer(sharpeAnalyzer)
drawDownAnalyzer = drawdown.DrawDown()
myStrategy.attachAnalyzer(drawDownAnalyzer)
tradesAnalyzer = trades.Trades()
myStrategy.attachAnalyzer(tradesAnalyzer)
plter = plotter.StrategyPlotter(myStrategy)
plter.getOrCreateSubplot("return").addDataSeries("retuens",
retAnalyzer.getReturns())
plter.getOrCreateSubplot("CumReturn").addDataSeries(
"CumReturn", retAnalyzer.getCumulativeReturns())
myStrategy.run()
plter.savePlot("testdata.png")
print("交易次数:%d" % (tradesAnalyzer.getCount()))
return (myStrategy, retAnalyzer, sharpeAnalyzer, drawDownAnalyzer,
tradesAnalyzer)
def testShort2(self):
strat = self.__createStrategy()
stratAnalyzer = trades.Trades()
strat.attachAnalyzer(stratAnalyzer)
# Enter short
strat.addOrder(buildUTCDateTime(2011, 1, 3, 15, 0),
strat.getBroker().createMarketOrder,
broker.Order.Action.SELL_SHORT, INSTRUMENT, 1) # 127.14
# Extend short position
strat.addOrder(buildUTCDateTime(2011, 1, 3, 15, 16),
strat.getBroker().createMarketOrder,
broker.Order.Action.SELL_SHORT, INSTRUMENT, 1) # 127.16
# Exit short
strat.addOrder(buildUTCDateTime(2011, 1, 3, 15, 30),
strat.getBroker().createMarketOrder,
broker.Order.Action.BUY_TO_COVER, INSTRUMENT,
2) # 127.2
strat.run()
self.assertEqual(
round(strat.getBroker().getBalance(PRICE_CURRENCY), 2),
round(1000 + (127.14 - 127.2) + (127.16 - 127.2), 2))
self.assertTrue(stratAnalyzer.getCount() == 1)
self.assertTrue(stratAnalyzer.getEvenCount() == 0)
self.assertEqual(round(stratAnalyzer.getAll().mean(), 2), -0.1)
self.assertTrue(stratAnalyzer.getUnprofitableCount() == 1)
self.assertTrue(round(stratAnalyzer.getLosses().mean(), 2) == -0.1)
self.assertTrue(stratAnalyzer.getProfitableCount() == 0)
def testLongShort(self):
strat = self.__createStrategy()
stratAnalyzer = trades.Trades()
strat.attachAnalyzer(stratAnalyzer)
# Enter long
strat.addOrder(buildUTCDateTime(2011, 1, 3, 15, 0), strat.getBroker().createMarketOrder, broker.Order.Action.BUY, TradesAnalyzerTestCase.TestInstrument, 1) # 127.14
# Exit long and enter short
strat.addOrder(buildUTCDateTime(2011, 1, 3, 15, 16), strat.getBroker().createMarketOrder, broker.Order.Action.SELL, TradesAnalyzerTestCase.TestInstrument, 2) # 127.16
# Exit short
strat.addOrder(buildUTCDateTime(2011, 1, 3, 15, 30), strat.getBroker().createMarketOrder, broker.Order.Action.BUY_TO_COVER, TradesAnalyzerTestCase.TestInstrument, 1) # 127.2
strat.run()
self.assertTrue(round(strat.getBroker().getCash(), 2) == round(1000 + (127.16 - 127.14) + (127.16 - 127.2), 2))
self.assertTrue(stratAnalyzer.getCount() == 2)
self.assertTrue(stratAnalyzer.getEvenCount() == 0)
self.assertTrue(round(stratAnalyzer.getAll().mean(), 2) == -0.01)
self.assertTrue(round(stratAnalyzer.getAll().std(ddof=1), 4) == 0.0424)
self.assertTrue(stratAnalyzer.getProfitableCount() == 1)
self.assertTrue(round(stratAnalyzer.getProfits().mean(), 2) == 0.02)
self.assertTrue(stratAnalyzer.getUnprofitableCount() == 1)
self.assertTrue(round(stratAnalyzer.getLosses().mean(), 2) == -0.04)
def __init__(self,
instrument,
startYear,
endYear,
strategy,
base="510300",
cash=1000000,
feeRate=0.0003):
self.__instrument = instrument
self.__startYear = startYear
self.__endYear = endYear
self.__strategy = strategy
self.__base = []
self.__base.append(base)
self.__cash = cash
self.__feeRate = feeRate
# 要创建的内部变量
self.__strategyTest = None
self.__feed = None
self.__strategyBase = None
self.__feedBase = None
self.__brk = None
self.__brkBase = None
self.__return = returns.Returns()
self.__returnBase = returns.Returns()
self.__sharpe = sharpe.SharpeRatio()
self.__drawdown = drawdown.DrawDown()
self.__trade = trades.Trades()
self.__result = pd.DataFrame()
self.__plter = None
# 使用pyalgotrade绘图要加上，不然报错
register_matplotlib_converters()
def testProportionalCommissionBug(self):
# Regression test for a bug reported by 'Jackson Sam' on 30/Aug/2013.
strat = self.__createStrategy()
strat.getBroker().setCommission(backtesting.FixedPerTrade(0.01))
stratAnalyzer = trades.Trades()
strat.attachAnalyzer(stratAnalyzer)
# There are 3 trades here:
# Trade 1 (Long)
# Buy 1 @ 127.16 Commission: 0.01
# Sell 1 @ 127.26 Commission: 0.005
# Trade 2 (Short)
# Sell 1 @ 127.26 Commission: 0.005
# Buy 1 @ 127.37 Commission: 0.005
# Trade 3 (Long)
# Buy 1 @ 127.37 Commission: 0.005
# Sell 1 @ 127.4 Commission: 0.01
strat.addOrder(buildUTCDateTime(2011, 1, 3, 15, 38), strat.getBroker().createMarketOrder, broker.Order.Action.BUY, TradesAnalyzerTestCase.TestInstrument, 1) # Fill at 127.16
strat.addOrder(buildUTCDateTime(2011, 1, 3, 15, 42), strat.getBroker().createMarketOrder, broker.Order.Action.SELL, TradesAnalyzerTestCase.TestInstrument, 2) # Fill at 127.26
strat.addOrder(buildUTCDateTime(2011, 1, 3, 15, 53), strat.getBroker().createMarketOrder, broker.Order.Action.BUY, TradesAnalyzerTestCase.TestInstrument, 2) # Fill at 127.37
strat.addOrder(buildUTCDateTime(2011, 1, 3, 15, 58), strat.getBroker().createMarketOrder, broker.Order.Action.SELL, TradesAnalyzerTestCase.TestInstrument, 1) # Fill at 127.4
strat.run()
allReturns = stratAnalyzer.getAllReturns()
self.assertEqual(round(allReturns[0], 6), 0.000668)
self.assertEqual(round(allReturns[1], 6), -0.000943)
self.assertEqual(round(allReturns[2], 6), 0.000118)
def __init__(self, feed, brk, instrument):
super(LiveStrategy, self).__init__(feed, brk)
brk.addBitmexFeed(feed)
feed.getNewValuesEvent().subscribe(self.__onBarsImpl)
self.initial_capital = self.getResult()
brk.setStrategy(self)
self.positions = {}
for symbol in instrument:
self.positions[symbol] = brk.get_synced_position(self, symbol)
retAnalyzer = returns.Returns()
self.attachAnalyzerEx(retAnalyzer, 'retAnalyzer')
sharpeRatioAnalyzer = sharpe.SharpeRatio()
self.attachAnalyzerEx(sharpeRatioAnalyzer, 'sharpeRatioAnalyzer')
drawDownAnalyzer = drawdown.DrawDown()
self.attachAnalyzerEx(drawDownAnalyzer, 'drawDownAnalyzer')
tradesAnalyzer = trades.Trades()
self.attachAnalyzerEx(tradesAnalyzer, 'tradesAnalyzer')
self.plt = plotter.StrategyPlotter(self)
self.plt.getOrCreateSubplot("returns").addDataSeries(
"Net return", retAnalyzer.getReturns())
self.plt.getOrCreateSubplot("returns").addDataSeries(
"Cum. return", retAnalyzer.getCumulativeReturns())
self.strategy_id = brk.getStrategyId()
if not os.path.exists(self.strategy_id + '.csv'):
with open(self.strategy_id + '.csv', 'w') as f:
f.write('Date,Type,Signal,Symbol,Price,Shares,PnL,Cash\n')
if not os.path.exists(self.strategy_id + '_orders.csv'):
with open(self.strategy_id + '_orders.csv', 'w') as f:
f.write(
'Date,OrderDate,OrderId,Type,Signal,Symbol,Price,Size,Filled,Timedelta,StopHit\n'
)
def run_strategy(smaPeriod, factor1):
import pandas as pd
# df_new = pd.DataFrame(columns=('shares_ID', 'total number of trades','Profit times number of trades','Final portfolio value'))
for (root, dirs, files) in os.walk("E:/SHZQ"):
for x in range(len(files)):
feed = GenericBarFeed(Frequency.DAY, None, None)
feed.addBarsFromCSV("fd", "E:/SHZQ/" + files[x])
myStrategy = MyStrategy(feed, "fd", smaPeriod, factor1)
trade_situation = trades.Trades()
myStrategy.attachAnalyzer(trade_situation)
myStrategy.run()
print(files[x] + "Final portfolio value:$%.2f" %
myStrategy.getBroker().getEquity())
print("total number of trades", trade_situation.getCount())
print("Profit times number of trades ",
trade_situation.getProfitableCount())
print(
"百分比",
trade_situation.getProfitableCount() /
trade_situation.getCount())
print(trade_situation.getCount())
df1 = pd.DataFrame({
"shares_ID": [files[x]],
'total number of trades': [trade_situation.getCount()],
'Profit times number of trades':
trade_situation.getProfitableCount(),
'Final portfolio value': [myStrategy.getBroker().getEquity()]
})
def run_strategy(smaPeriod):
# Load the yahoo feed from the CSV file
feed = yahoofeed.Feed()
feed.addBarsFromCSV("zggf", "E:/PythonData/CSV/000938.csv")
# Evaluate the strategy with the feed.
myStrategy = MyStrategy(feed, "zggf", smaPeriod)
returnsAnalyzer = returns.Returns()
myStrategy.attachAnalyzer(returnsAnalyzer)
plt = plotter.StrategyPlotter(myStrategy)
sharpe_ratio = sharpe.SharpeRatio()
trade_situation = trades.Trades()
myStrategy.attachAnalyzer(sharpe_ratio)
myStrategy.attachAnalyzer(trade_situation)
plt.getInstrumentSubplot("zggf").addDataSeries("SMA", myStrategy.getSMA())
plt.getOrCreateSubplot("returns").addDataSeries(
"Simple returns", returnsAnalyzer.getCumulativeReturns())
print(stats.mean(returnsAnalyzer.getReturns()))
print(returnsAnalyzer.getCumulativeReturns())
print(myStrategy.getResult())
myStrategy.run()
print("Final portfolio value: $%.2f" % myStrategy.getBroker().getEquity())
print("sharpe_ratio", sharpe_ratio.getSharpeRatio(0))
print("total number of trades", trade_situation.getCount())
print("Profit times number of trades ",
trade_situation.getProfitableCount())
plt.plot()
print(returnsAnalyzer.getReturns())
print(stats.mean(returnsAnalyzer.getReturns()))
print(stats.mean(returnsAnalyzer.getCumulativeReturns()))
def __init__(self, feed, instrument):
super(SimpleBacktestStrategy, self).__init__(feed)
self.initial_capital = self.getResult()
self.positions = {}
for symbol in instrument:
self.positions[symbol] = {}
retAnalyzer = returns.Returns()
self.attachAnalyzerEx(retAnalyzer, 'retAnalyzer')
sharpeRatioAnalyzer = sharpe.SharpeRatio()
self.attachAnalyzerEx(sharpeRatioAnalyzer, 'sharpeRatioAnalyzer')
drawDownAnalyzer = drawdown.DrawDown()
self.attachAnalyzerEx(drawDownAnalyzer, 'drawDownAnalyzer')
tradesAnalyzer = trades.Trades()
self.attachAnalyzerEx(tradesAnalyzer, 'tradesAnalyzer')
self.plt = plotter.StrategyPlotter(self)
self.plt.getOrCreateSubplot("returns").addDataSeries(
"Net return", retAnalyzer.getReturns())
self.plt.getOrCreateSubplot("returns").addDataSeries(
"Cum. return", retAnalyzer.getCumulativeReturns())
self.strategy_id = 'backtest'
if not os.path.exists(self.strategy_id + '.csv'):
with open(self.strategy_id + '.csv', 'w') as f:
f.write('Date,Type,Signal,Symbol,Price,Shares,PnL,Cash\n')
def testLong3(self):
strat = self.__createStrategy()
stratAnalyzer = trades.Trades()
strat.attachAnalyzer(stratAnalyzer)
# Enter long
strat.addOrder(buildUTCDateTime(2011, 1, 3, 15, 0),
strat.getBroker().createMarketOrder,
broker.Order.Action.BUY, INSTRUMENT, 2) # 127.14
# Decrease long position
strat.addOrder(buildUTCDateTime(2011, 1, 3, 15, 16),
strat.getBroker().createMarketOrder,
broker.Order.Action.SELL, INSTRUMENT, 1) # 127.16
# Exit long
strat.addOrder(buildUTCDateTime(2011, 1, 3, 15, 30),
strat.getBroker().createMarketOrder,
broker.Order.Action.SELL, INSTRUMENT, 1) # 127.2
strat.run()
self.assertEqual(
round(strat.getBroker().getBalance(PRICE_CURRENCY), 2),
round(1000 + (127.2 - 127.14) + (127.16 - 127.14), 2))
self.assertTrue(stratAnalyzer.getCount() == 1)
self.assertTrue(stratAnalyzer.getEvenCount() == 0)
self.assertTrue(round(stratAnalyzer.getAll().mean(), 2) == 0.08)
self.assertTrue(stratAnalyzer.getProfitableCount() == 1)
self.assertTrue(round(stratAnalyzer.getProfits().mean(), 2) == 0.08)
self.assertTrue(stratAnalyzer.getUnprofitableCount() == 0)
def run_strategy(smaPeriod):
# Load the yahoo feed from the CSV file
feed = yahoofeed.Feed()
feed.addBarsFromCSV("zggf", "E:/PythonData/CSV/000938.csv")
# Evaluate the strategy with the feed.
myStrategy = MyStrategy(feed, "zggf", smaPeriod)
returnsAnalyzer=returns.Returns()
myStrategy.attachAnalyzer(returnsAnalyzer)
sharpeRatioAnalyzer = sharpe.SharpeRatio()
myStrategy.attachAnalyzer(sharpeRatioAnalyzer)
drawDownAnalyzer = drawdown.DrawDown()
myStrategy.attachAnalyzer(drawDownAnalyzer)
tradesAnalyzer = trades.Trades()
myStrategy.attachAnalyzer(tradesAnalyzer)
myStrategy.run()
print(myStrategy.getResult())
print("Final portfolio value: $%.2f" % myStrategy.getResult())
print("Cumulative returns: %.2f %%" % (returnsAnalyzer.getCumulativeReturns()[-1] * 100))
print(returnsAnalyzer.getCumulativeReturns())
print("Sharpe ratio: %.2f" % (sharpeRatioAnalyzer.getSharpeRatio(0.05)))
print("Max. drawdown: %.2f %%" % (drawDownAnalyzer.getMaxDrawDown() * 100))
print("Longest drawdown duration: %s" % (drawDownAnalyzer.getLongestDrawDownDuration()))
print()
print("Total trades: %d" % (tradesAnalyzer.getCount()))
def testShort2(self):
strat = self.__createStrategy()
stratAnalyzer = trades.Trades()
strat.attachAnalyzer(stratAnalyzer)
# Enter short
strat.addOrder(datetime.datetime(2011, 1, 3, 15, 0),
strat.getBroker().createMarketOrder,
broker.Order.Action.SELL_SHORT,
TradesAnalyzerTestCase.TestInstrument, 1) # 127.14
# Extend short position
strat.addOrder(datetime.datetime(2011, 1, 3, 15, 16),
strat.getBroker().createMarketOrder,
broker.Order.Action.SELL_SHORT,
TradesAnalyzerTestCase.TestInstrument, 1) # 127.16
# Exit short
strat.addOrder(datetime.datetime(2011, 1, 3, 15, 30),
strat.getBroker().createMarketOrder,
broker.Order.Action.BUY_TO_COVER,
TradesAnalyzerTestCase.TestInstrument, 2) # 127.2
strat.run()
self.assertTrue(
round(strat.getBroker().getCash(), 2) == round(
1000 + (127.14 - 127.2) + (127.16 - 127.2), 2))
self.assertTrue(stratAnalyzer.getCount() == 1)
self.assertTrue(stratAnalyzer.getEvenCount() == 0)
self.assertTrue(round(stratAnalyzer.getMean(), 2) == -0.1)
self.assertTrue(stratAnalyzer.getLosingCount() == 1)
self.assertTrue(round(stratAnalyzer.getLosingMean(), 2) == -0.1)
self.assertTrue(stratAnalyzer.getWinningCount() == 0)
def testLong3(self):
strat = self.__createStrategy()
stratAnalyzer = trades.Trades()
strat.attachAnalyzer(stratAnalyzer)
# Enter long
strat.addOrder(datetime.datetime(2011, 1, 3, 15, 0),
strat.getBroker().createMarketOrder,
broker.Order.Action.BUY,
TradesAnalyzerTestCase.TestInstrument, 2) # 127.14
# Decrease long position
strat.addOrder(datetime.datetime(2011, 1, 3, 15, 16),
strat.getBroker().createMarketOrder,
broker.Order.Action.SELL,
TradesAnalyzerTestCase.TestInstrument, 1) # 127.16
# Exit long
strat.addOrder(datetime.datetime(2011, 1, 3, 15, 30),
strat.getBroker().createMarketOrder,
broker.Order.Action.SELL,
TradesAnalyzerTestCase.TestInstrument, 1) # 127.2
strat.run()
self.assertTrue(
round(strat.getBroker().getCash(), 2) == round(
1000 + (127.2 - 127.14) + (127.16 - 127.14), 2))
self.assertTrue(stratAnalyzer.getCount() == 1)
self.assertTrue(stratAnalyzer.getEvenCount() == 0)
self.assertTrue(round(stratAnalyzer.getMean(), 2) == 0.08)
self.assertTrue(stratAnalyzer.getWinningCount() == 1)
self.assertTrue(round(stratAnalyzer.getWinningMean(), 2) == 0.08)
self.assertTrue(stratAnalyzer.getLosingCount() == 0)
def testSomeTrades(self):
strat = self.__createStrategy()
stratAnalyzer = trades.Trades()
strat.attachAnalyzer(stratAnalyzer)
# Winning trade
strat.addOrder(datetime.datetime(2011, 1, 3, 15, 0),
strat.getBroker().createMarketOrder,
broker.Order.Action.BUY,
TradesAnalyzerTestCase.TestInstrument, 1) # 127.14
strat.addOrder(datetime.datetime(2011, 1, 3, 15, 16),
strat.getBroker().createMarketOrder,
broker.Order.Action.SELL,
TradesAnalyzerTestCase.TestInstrument, 1) # 127.16
# Losing trade
strat.addOrder(datetime.datetime(2011, 1, 3, 15, 30),
strat.getBroker().createMarketOrder,
broker.Order.Action.BUY,
TradesAnalyzerTestCase.TestInstrument, 1) # 127.2
strat.addOrder(datetime.datetime(2011, 1, 3, 15, 31),
strat.getBroker().createMarketOrder,
broker.Order.Action.SELL,
TradesAnalyzerTestCase.TestInstrument, 1) # 127.16
# Winning trade
strat.addOrder(datetime.datetime(2011, 1, 3, 15, 38),
strat.getBroker().createMarketOrder,
broker.Order.Action.BUY,
TradesAnalyzerTestCase.TestInstrument, 1) # 127.16
strat.addOrder(datetime.datetime(2011, 1, 3, 15, 42),
strat.getBroker().createMarketOrder,
broker.Order.Action.SELL,
TradesAnalyzerTestCase.TestInstrument, 1) # 127.26
# Open trade.
strat.addOrder(datetime.datetime(2011, 1, 3, 15, 47),
strat.getBroker().createMarketOrder,
broker.Order.Action.BUY,
TradesAnalyzerTestCase.TestInstrument, 1) # 127.34
strat.run()
self.assertTrue(
round(strat.getBroker().getCash(), 2) == round(
1000 + (127.16 - 127.14) + (127.16 - 127.2) +
(127.26 - 127.16) - 127.34, 2))
self.assertTrue(stratAnalyzer.getCount() == 3)
self.assertTrue(stratAnalyzer.getEvenCount() == 0)
self.assertTrue(round(stratAnalyzer.getMean(), 2) == 0.03)
self.assertTrue(round(stratAnalyzer.getStdDev(), 2) == 0.07)
self.assertTrue(round(stratAnalyzer.getStdDev(0), 2) == 0.06)
self.assertTrue(stratAnalyzer.getWinningCount() == 2)
self.assertTrue(round(stratAnalyzer.getWinningMean(), 2) == 0.06)
self.assertTrue(round(stratAnalyzer.getWinningStdDev(), 2) == 0.06)
self.assertTrue(round(stratAnalyzer.getWinningStdDev(0), 2) == 0.04)
self.assertTrue(stratAnalyzer.getLosingCount() == 1)
self.assertTrue(round(stratAnalyzer.getLosingMean(), 2) == -0.04)
self.assertTrue(math.isnan(stratAnalyzer.getLosingStdDev()))
self.assertTrue(stratAnalyzer.getLosingStdDev(0) == 0)
def testSomeTrades(self):
strat = self.__createStrategy()
stratAnalyzer = trades.Trades()
strat.attachAnalyzer(stratAnalyzer)
# Winning trade
strat.addOrder(buildUTCDateTime(2011, 1, 3, 15, 0),
strat.getBroker().createMarketOrder,
broker.Order.Action.BUY, INSTRUMENT, 1) # 127.14
strat.addOrder(buildUTCDateTime(2011, 1, 3, 15, 16),
strat.getBroker().createMarketOrder,
broker.Order.Action.SELL, INSTRUMENT, 1) # 127.16
# Losing trade
strat.addOrder(buildUTCDateTime(2011, 1, 3, 15, 30),
strat.getBroker().createMarketOrder,
broker.Order.Action.BUY, INSTRUMENT, 1) # 127.2
strat.addOrder(buildUTCDateTime(2011, 1, 3, 15, 31),
strat.getBroker().createMarketOrder,
broker.Order.Action.SELL, INSTRUMENT, 1) # 127.16
# Winning trade
strat.addOrder(buildUTCDateTime(2011, 1, 3, 15, 38),
strat.getBroker().createMarketOrder,
broker.Order.Action.BUY, INSTRUMENT, 1) # 127.16
strat.addOrder(buildUTCDateTime(2011, 1, 3, 15, 42),
strat.getBroker().createMarketOrder,
broker.Order.Action.SELL, INSTRUMENT, 1) # 127.26
# Open trade.
strat.addOrder(buildUTCDateTime(2011, 1, 3, 15, 47),
strat.getBroker().createMarketOrder,
broker.Order.Action.BUY, INSTRUMENT, 1) # 127.34
strat.run()
self.assertEqual(
round(strat.getBroker().getBalance(PRICE_CURRENCY), 2),
round(
1000 + (127.16 - 127.14) + (127.16 - 127.2) +
(127.26 - 127.16) - 127.34, 2))
self.assertTrue(stratAnalyzer.getCount() == 3)
self.assertTrue(stratAnalyzer.getEvenCount() == 0)
self.assertTrue(round(stratAnalyzer.getAll().mean(), 2) == 0.03)
self.assertTrue(round(stratAnalyzer.getAll().std(ddof=1), 2) == 0.07)
self.assertTrue(round(stratAnalyzer.getAll().std(ddof=0), 2) == 0.06)
self.assertTrue(stratAnalyzer.getProfitableCount() == 2)
self.assertTrue(round(stratAnalyzer.getProfits().mean(), 2) == 0.06)
self.assertTrue(
round(stratAnalyzer.getProfits().std(ddof=1), 2) == 0.06)
self.assertTrue(
round(stratAnalyzer.getProfits().std(ddof=0), 2) == 0.04)
self.assertTrue(stratAnalyzer.getUnprofitableCount() == 1)
self.assertTrue(round(stratAnalyzer.getLosses().mean(), 2) == -0.04)
if version.LooseVersion(
numpy.__version__) >= version.LooseVersion("1.6.2"):
self.assertTrue(math.isnan(stratAnalyzer.getLosses().std(ddof=1)))
else:
self.assertTrue(stratAnalyzer.getLosses().std(ddof=1) == 0)
self.assertTrue(stratAnalyzer.getLosses().std(ddof=0) == 0)
def RSIBacktest(nper):
# Create Instruments object with stock tickers
instruments = ["BANKNIFTY"]
# create feed object, add bars to the data feed
feed = csvfeed.GenericBarFeed(bar.Frequency.DAY)
feed.addBarsFromCSV(instruments[0], "Data//bnf.csv")
# create object to run strategy
rsi_strat = RSIStrategy(feed, instruments[0], nper)
# Attach Strategy Plotter
plt = plotter.StrategyPlotter(rsi_strat,
plotAllInstruments=True,
plotBuySell=True,
plotPortfolio=False)
plt.getOrCreateSubplot("RSI").addDataSeries("RSI", rsi_strat.getRSI())
plt.getOrCreateSubplot("RSI").addLine("Upper Threshold", 70)
plt.getOrCreateSubplot("RSI").addLine("Lower Threshold", 40)
# plt.getOrCreateSubplot("RSI").addLine("Center Line", 40)
retAnalyzer = ret.Returns()
rsi_strat.attachAnalyzer(retAnalyzer)
sharpeRatioAnalyzer = sharpe.SharpeRatio()
rsi_strat.attachAnalyzer(sharpeRatioAnalyzer)
drawDownAnalyzer = drawdown.DrawDown()
rsi_strat.attachAnalyzer(drawDownAnalyzer)
tradesAnalyzer = trades.Trades()
rsi_strat.attachAnalyzer(tradesAnalyzer)
# Run Strategy
rsi_strat.run()
# Print Strategy Trading Statistics
print
print "------------------------------"
print "1. Portfolio statistics"
print
print "Portfolio initial equity: $100000.00"
print "Portfolio final equity: $%.2f" % rsi_strat.getBroker().getEquity()
print "Portfolio net trading p&l: $%.2f" % tradesAnalyzer.getAll().sum()
print "Portfolio maximum drawdown: %.2f %%" % (
drawDownAnalyzer.getMaxDrawDown() * 100)
print "Portfolio annualized return: %.2f %%" % (
retAnalyzer.getCumulativeReturns()[-1] * 100)
print "Portfolio annualized Sharpe ratio (Rf = 0%%): %.2f" % (
sharpeRatioAnalyzer.getSharpeRatio(0.0))
print "------------------------------"
print "2. Total trades statistics"
print "Total trades: %d" % (tradesAnalyzer.getCount())
if tradesAnalyzer.getCount() > 0:
tradesProfits = tradesAnalyzer.getAll()
print "Total trades average p&l: $%2.f" % (tradesProfits.mean())
print "Largest Winning Trade: $%2.f" % (tradesProfits.max())
print "Largest Losing Trade: $%2.f" % (tradesProfits.min())
tradesReturns = tradesAnalyzer.getAllReturns()
print "Average return: %2.f %%" % (tradesReturns.mean() * 100)
print "Largest Winning Trade Return: %2.f %%" % (tradesReturns.max() *
100)
print "Largest Losing Trade Return: %2.f %%" % (tradesReturns.min() *
100)
print "------------------------------"
# Plot Strategy
plt.plot()
def main(plot):
instrument = ["price_diff", 'SHFE_AU', 'COMEX_AU']
bBandsPeriod = 20
# Download the bars.
feed = GenericBarFeed(Frequency.DAY, None, None)
feed.addBarsFromCSV('price_diff', 'price_oneyear_diff.csv')
feed.addBarsFromCSV('SHFE_AU', 'AU_oneyear_samedate.csv')
feed.addBarsFromCSV('COMEX_AU', 'GC_oneyear_samedate.csv')
# 3. broker setting
broker_commission = broker.backtesting.FixedPerTrade(390) # 2230
fill_stra = broker.fillstrategy.DefaultStrategy(volumeLimit=1)
sli_stra = broker.slippage.VolumeShareSlippage(priceImpact=0.2)
fill_stra.setSlippageModel(sli_stra)
brk = broker.backtesting.Broker(10000000, feed, broker_commission)
brk.setFillStrategy(fill_stra)
strat = BBands(feed, instrument[0], instrument[1], instrument[2],
bBandsPeriod, brk)
sharpeRatioAnalyzer = sharpe.SharpeRatio()
strat.attachAnalyzer(sharpeRatioAnalyzer)
trade_situation = trades.Trades()
strat.attachAnalyzer(trade_situation)
draw_down = drawdown.DrawDown()
strat.attachAnalyzer(draw_down)
returning = returns.Returns()
strat.attachAnalyzer(returning)
if plot:
plt = plotter.StrategyPlotter(strat, True, True, True)
plt.getInstrumentSubplot(instrument[0]).addDataSeries(
"upper",
strat.getBollingerBands().getUpperBand())
plt.getInstrumentSubplot(instrument[0]).addDataSeries(
"middle",
strat.getBollingerBands().getMiddleBand())
plt.getInstrumentSubplot(instrument[0]).addDataSeries(
"lower",
strat.getBollingerBands().getLowerBand())
strat.run()
strat.info('最终资产值: ¥ %.2f' % strat.getResult()) #info表示记录每一次的交易
print '夏普率: ', sharpeRatioAnalyzer.getSharpeRatio(0.05,
False) #print表示只打印一次
print '累计收益率：', (returning.getCumulativeReturns()[-1])
print '最大回撤：', draw_down.getMaxDrawDown()
print '总交易次数：', trade_situation.getCount()
print '每次交易的手续费：', trade_situation.getCommissionsForAllTrades()
print '赚钱的交易次数：', trade_situation.getProfitableCount()
print '亏损的交易次数：', trade_situation.getUnprofitableCount()
print '不赚不亏的交易次数：', trade_situation.getEvenCount()
print '每次交易的盈亏：', trade_situation.getAll()
if plot:
plt.plot()
def testSomeTrades_Position(self):
strat = self.__createPositionStrategy()
stratAnalyzer = trades.Trades()
strat.attachAnalyzer(stratAnalyzer)
# Winning trade
strat.addPosEntry(buildUTCDateTime(2011, 1, 3, 15, 0), strat.enterLong,
TradesAnalyzerTestCase.TestInstrument, 1) # 127.14
strat.addPosExit(buildUTCDateTime(2011, 1, 3, 15, 16)) # 127.16
# Losing trade
strat.addPosEntry(buildUTCDateTime(2011, 1, 3, 15,
30), strat.enterLong,
TradesAnalyzerTestCase.TestInstrument, 1) # 127.2
strat.addPosExit(buildUTCDateTime(2011, 1, 3, 15, 31)) # 127.16
# Winning trade
strat.addPosEntry(buildUTCDateTime(2011, 1, 3, 15,
38), strat.enterLong,
TradesAnalyzerTestCase.TestInstrument, 1) # 127.16
strat.addPosExit(buildUTCDateTime(2011, 1, 3, 15, 42)) # 127.26
# Unfinished trade not closed
strat.addPosEntry(buildUTCDateTime(2011, 1, 3, 15,
47), strat.enterLong,
TradesAnalyzerTestCase.TestInstrument, 1) # 127.34
strat.run()
self.assertTrue(
round(strat.getBroker().getCash(), 2) == round(
1000 + (127.16 - 127.14) + (127.16 - 127.2) +
(127.26 - 127.16) - 127.34, 2))
self.assertTrue(stratAnalyzer.getCount() == 3)
self.assertTrue(stratAnalyzer.getEvenCount() == 0)
self.assertTrue(round(stratAnalyzer.getAll().mean(), 2) == 0.03)
self.assertTrue(round(stratAnalyzer.getAll().std(ddof=1), 2) == 0.07)
self.assertTrue(round(stratAnalyzer.getAll().std(ddof=0), 2) == 0.06)
self.assertTrue(stratAnalyzer.getProfitableCount() == 2)
self.assertTrue(round(stratAnalyzer.getProfits().mean(), 2) == 0.06)
self.assertTrue(
round(stratAnalyzer.getProfits().std(ddof=1), 2) == 0.06)
self.assertTrue(
round(stratAnalyzer.getProfits().std(ddof=0), 2) == 0.04)
self.assertEqual(stratAnalyzer.getPositiveReturns()[0],
(127.16 - 127.14) / 127.14)
self.assertEqual(stratAnalyzer.getPositiveReturns()[1],
(127.26 - 127.16) / 127.16)
self.assertTrue(stratAnalyzer.getUnprofitableCount() == 1)
self.assertTrue(round(stratAnalyzer.getLosses().mean(), 2) == -0.04)
if version.LooseVersion(
numpy.__version__) >= version.LooseVersion("1.6.2"):
self.assertTrue(math.isnan(stratAnalyzer.getLosses().std(ddof=1)))
else:
self.assertTrue(stratAnalyzer.getLosses().std(ddof=1) == 0)
self.assertTrue(stratAnalyzer.getLosses().std(ddof=0) == 0)
self.assertEqual(stratAnalyzer.getNegativeReturns()[0],
(127.16 - 127.2) / 127.2)
def turtle_test(code,start=None,plot=True,dl=60):
feed = ptc.get_tdx_barfeed(code,start,dl=dl)
#myStrategy = pyalg_test.SMACrossOver(feed, "orcl", 20)
pars=[2, 20, 60, 10]
# myStrategy = thrSMA_dayinfo(feed, "orcl",*pars)
myStrategy = BBands(feed, code,20,dl)
# Attach a returns analyzers to the strategy.
# returnsAnalyzer = returns.Returns()
# myStrategy.attachAnalyzer(returnsAnalyzer)
# if dataString =='pyalg_util':
# ds = pyalg_utils.dataSet(myStrategy) #抽取交易数据集语句，若使用系统自带画图功能则不需要该项
from pyalgotrade.stratanalyzer import returns
from pyalgotrade.stratanalyzer import sharpe
from pyalgotrade.stratanalyzer import drawdown
from pyalgotrade.stratanalyzer import trades
retAnalyzer = returns.Returns()
myStrategy.attachAnalyzer(retAnalyzer)
sharpeRatioAnalyzer = sharpe.SharpeRatio()
myStrategy.attachAnalyzer(sharpeRatioAnalyzer)
drawDownAnalyzer = drawdown.DrawDown()
myStrategy.attachAnalyzer(drawDownAnalyzer)
tradesAnalyzer = trades.Trades()
myStrategy.attachAnalyzer(tradesAnalyzer)
# Attach the plotter to the strategy.
# plt = plotter.StrategyPlotter(myStrategy)
# Plot the simple returns on each bar.
if plot:
plt = plotter.StrategyPlotter(myStrategy, True, True, True)
plt.getOrCreateSubplot("returns").addDataSeries("Simple returns", retAnalyzer.getReturns())
myStrategy.run()
myStrategy.info("Final portfolio value: $%.2f" % myStrategy.getResult())
# if dataString =='pyalg_util':
# rs = ds.getDefault() #获取默认的交易信息，dic格式
# plot(rs["cumulativeReturns"][:,0],rs["cumulativeReturns"][:,1]) #简单作图示例
#夏普率
sharp = sharpeRatioAnalyzer.getSharpeRatio(0.05)
#最大回撤
maxdd = drawDownAnalyzer.getMaxDrawDown()
#收益率
return_ = retAnalyzer.getCumulativeReturns()[-1]
#收益曲线
return_list = []
for item in retAnalyzer.getCumulativeReturns():
return_list.append(item)
print "Sharpe ratio: %.2f maxdown:%.2f%% return:%.2f%%" %(sharp,maxdd*100,return_*100)
myStrategy.get_max_min()
plt.plot()
def testStrategy():
from pyalgotrade import bar
from pyalgotrade import plotter
strat = thrSMA
instrument = '600519'
market = 'SH'
fromDate = '20101001'
toDate = '20150601'
frequency = bar.Frequency.DAY
paras = [5, 17, 40, 10]
plot = True
import os
filepath = os.path.join(r'E:\xsj\day', instrument + market + ".csv")
#############################################don't change ############################33
from pyalgotrade.cn.csvfeed import Feed
barfeed = Feed(frequency)
barfeed.setDateTimeFormat('%Y-%m-%d')
barfeed.loadBars(instrument, market, fromDate, toDate, filepath)
pyalgotrade_id = instrument + '.' + market
strat = strat(barfeed, pyalgotrade_id, *paras)
from pyalgotrade.stratanalyzer import returns
from pyalgotrade.stratanalyzer import sharpe
from pyalgotrade.stratanalyzer import drawdown
from pyalgotrade.stratanalyzer import trades
retAnalyzer = returns.Returns()
strat.attachAnalyzer(retAnalyzer)
sharpeRatioAnalyzer = sharpe.SharpeRatio()
strat.attachAnalyzer(sharpeRatioAnalyzer)
drawDownAnalyzer = drawdown.DrawDown()
strat.attachAnalyzer(drawDownAnalyzer)
tradesAnalyzer = trades.Trades()
strat.attachAnalyzer(tradesAnalyzer)
if plot:
plt = plotter.StrategyPlotter(strat, True, True, True)
strat.run()
if plot:
plt.plot()
#夏普率
sharp = sharpeRatioAnalyzer.getSharpeRatio(0.05)
#最大回撤
maxdd = drawDownAnalyzer.getMaxDrawDown()
#收益率
return_ = retAnalyzer.getCumulativeReturns()[-1]
#收益曲线
return_list = []
for item in retAnalyzer.getCumulativeReturns():
return_list.append(item)
def main(mode = ct.PAPER_TRADING, start_date = '20170815', end_date = '20171113'):
if mode == ct.PAPER_TRADING:
cash = 100000
beta = 9.49
mean = -0.282
std = 34.73
feed = dataFramefeed.Feed()
instruments = ['300296', '300613']
fpath = '/Users/hellobiek/Documents/workspace/python/quant/smart_deal_tool/configure/tushare.json'
ts_client = get_tushare_client(fpath)
for code in instruments:
df = ts.pro_bar(pro_api = ts_client, ts_code = add_suffix(code), adj = 'qfq', start_date = start_date, end_date = end_date)
df = df.rename(columns = {"ts_code": "code", "trade_date": "date", "vol": "volume", "pct_change": "pchange"})
df['date'] = df.date.apply(lambda x: time.strftime('%Y-%m-%d', time.strptime(x, "%Y%m%d")))
df = df.set_index("date")
feed.addBarsFromDataFrame(code, df)
# broker setting
# broker commission类设置
broker_commission = broker.backtesting.TradePercentage(0.002)
# fill strategy设置
fill_stra = broker.fillstrategy.DefaultStrategy(volumeLimit = 1.0)
sli_stra = broker.slippage.NoSlippage()
fill_stra.setSlippageModel(sli_stra)
# 完善broker类
brk = broker.backtesting.Broker(cash, feed, broker_commission)
brk.setFillStrategy(fill_stra)
pStrategy = PairTradingStrategy(feed, instruments, brk, beta, mean, std, cash)
returnsAnalyzer = sreturn.Returns()
pStrategy.attachAnalyzer(returnsAnalyzer)
sharpeRatioAnalyzer = sharpe.SharpeRatio()
pStrategy.attachAnalyzer(sharpeRatioAnalyzer)
drawDownAnalyzer = drawdown.DrawDown()
pStrategy.attachAnalyzer(drawDownAnalyzer)
tradesAnalyzer = trades.Trades()
pStrategy.attachAnalyzer(tradesAnalyzer)
plt = plotter.StrategyPlotter(pStrategy)
# Plot the simple returns on each bar.
plt.getOrCreateSubplot("returns").addDataSeries("Simple returns", returnsAnalyzer.getReturns())
pStrategy.run()
plt.plot()
print("Final portfolio value: $%.2f" % pStrategy.getResult())
print("Cumulative returns: %.2f %%" % (returnsAnalyzer.getCumulativeReturns()[-1] * 100))
print("Sharpe ratio: %.2f" % (sharpeRatioAnalyzer.getSharpeRatio(0.05)))
print("Max. drawdown: %.2f %%" % (drawDownAnalyzer.getMaxDrawDown() * 100))
print("Longest drawdown duration: %s" % (drawDownAnalyzer.getLongestDrawDownDuration()))
def initAnalyzer(self):
from pyalgotrade.stratanalyzer import sharpe
from pyalgotrade.stratanalyzer import returns
from pyalgotrade.stratanalyzer import drawdown
from pyalgotrade.stratanalyzer import trades
self.returnsAnalyzer = returns.Returns()
self.sharpeRatioAnalyzer = sharpe.SharpeRatio()
self.drawdownAnalyzer = drawdown.DrawDown()
self.tradesAnalyzer = trades.Trades()
def __init__(self, myStrategy):
self.__myStrategy = myStrategy
self.returnsAnalyzer = returns.Returns()
self.sharpeRatioAnalyzer = sharpe.SharpeRatio()
self.drawdownAnalyzer = drawdown.DrawDown()
self.tradeAyalyzer = trades.Trades()
myStrategy.attachAnalyzer(self.returnsAnalyzer)
myStrategy.attachAnalyzer(self.sharpeRatioAnalyzer)
myStrategy.attachAnalyzer(self.drawdownAnalyzer)
myStrategy.attachAnalyzer(self.tradeAyalyzer)
def testStrategy():
from pyalgotrade import bar
from pyalgotrade import plotter
strat = DoubleMA
frequency = bar.Frequency.MINUTE
paras = [5, 20]
plot = True
#############################################path set ############################33
feed = Feed(frequency)
feed.loadBars('bitmex_BCHZ18', test_back=True)
strat = strat(feed, "bitmex_BCHZ18", *paras)
from pyalgotrade.stratanalyzer import returns
from pyalgotrade.stratanalyzer import sharpe
from pyalgotrade.stratanalyzer import drawdown
from pyalgotrade.stratanalyzer import trades
retAnalyzer = returns.Returns()
strat.attachAnalyzer(retAnalyzer)
sharpeRatioAnalyzer = sharpe.SharpeRatio()
strat.attachAnalyzer(sharpeRatioAnalyzer)
drawDownAnalyzer = drawdown.DrawDown()
strat.attachAnalyzer(drawDownAnalyzer)
tradesAnalyzer = trades.Trades()
strat.attachAnalyzer(tradesAnalyzer)
if plot:
plt = plotter.StrategyPlotter(strat, True, True, True)
strat.run()
if plot:
plt.plot()
# 夏普率
sharp = sharpeRatioAnalyzer.getSharpeRatio(0.02)
print(sharp)
# 最大回撤
maxdd = drawDownAnalyzer.getMaxDrawDown()
print(maxdd)
# 收益率
return_ = retAnalyzer.getCumulativeReturns()[-1]
print(return_)
# 收益曲线
return_list = []
for item in retAnalyzer.getCumulativeReturns():
return_list.append(item)
print(return_list)
