用 Python 做股市数据分析！股民必备技能哦！还不get去？

概述 交易策略在特定的预期条件达成时一个开放头寸会被关闭。多头头寸表示交易中需要金融商品价格上升才能产生盈利，空头头寸表示交易中需要金融商品价格下降才能产生盈利。在股票交易中，多头头寸是牛市，空头头寸是

交易策略

在特定的预期条件达成时一个开放头寸会被关闭。多头头寸表示交易中需要金融商品价格上升才能产生盈利，空头头寸表示交易中需要金融商品价格下降才能产生盈利。在股票交易中，多头头寸是牛市，空头头寸是熊市，反之则不成立。（股票期权交易中这个非常典型）

进群:548377875   即可获取数十套pdf哦！

我们要设计一个交易策略，它包含用于快速交易的交易激发信号、决定交易额度的规则和完整的退出策略。我们的目标是设计并评估该交易策略。

假设每次交易金额占总额的比例是固定的（10%）。同时设定在每一次交易中，如果损失超过了20%的交易值，我们就退出头寸。现在我们要决定什么时候进入头寸，什么时候退出以保证盈利。

这里我要演示移动平均交汇点分析移动平均线的方法。我会使用两条移动平均线，一条快速的，另一条是慢速的。我们的策略是：

当快速移动平均线和慢速移动线交汇时开始交易 当快速移动平均线和慢速移动线再次交汇时停止交易

做多是指在快速平均线上升到慢速平均线之上时开始交易，当快速平均线下降到慢速平均线之下时停止交易。卖空正好相反，它是指在快速平均线下降到慢速平均线之下时开始交易，快速平均线上升到慢速平均线之上时停止交易。

现在我们有一整套策略了。在使用它之前我们需要先做一下测试。回溯测试是一个常用的测试方法，它使用历史数据来看策略是否会盈利。例如这张苹果公司的股票价值图，如果20天的移动平均是快速线，50天的移动平均是慢速线，那么我们这个策略不是很挣钱，至少在你一直做多头头寸的时候。

下面让我们来自动化回溯测试的过程。首先我们要识别什么时候20天平均线在50天之下，以及之上。

apple['20d-50d'] =apple['20d'] -apple['50d']

apple.tail()

我们将差异的符号称为状态转换。快速移动平均线在慢速移动平均线之上代表牛市状态；相反则为熊市。以下的代码用于识别状态转换。

# np.where() is a vectorized if-else function,where a condition is checked for each component of a vector,and the first argument passed is used when the condition holds,and the other passed if it does not

apple["Regime"] = np.where(apple['20d-50d'] > 0,1,0)

# We have 1's for bullish regimes and 0's for everything else. Below I replace bearish regimes's values with -1,and to maintain the rest of the vector,the second argument is apple["Regime"]

apple["Regime"] = np.where(apple['20d-50d'] < 0,-1,apple["Regime"])

apple.loc['2016-01-01':'2016-08-07',"Regime"].plot(ylim = (-2,2)).axhline(y = 0,color = "black",lw = 2)

apple["Regime"].plot(ylim =(-2,2)).axhline(y =0,color ="black",lw =2)

apple["Regime"].value_counts()

1 966

-1 663

0 50

name: Regime,dtype: int64

从上面的曲线可以看到有966天苹果公司的股票是牛市，663天是熊市，有54天没有倾向性。（原文中牛市和熊市说反了，译文中更正；原文数字跟代码结果对不上，译文按照代码结果更正）

交易信号出现在状态转换之时。牛市出现时，买入信号被激活；牛市完结时，卖出信号被激活。同样的，熊市出现时卖出信号被激活，熊市结束时，买入信号被激活。（只有在你空头股票，或者使用一些其他的方法例如用股票期权赌市场的时候这种情况才对你有利）

# To ensure that all Trades close out,I temporarily change the regime of the last row to 0

regime_orig = apple.ix[-1,"Regime"]

apple.ix[-1,"Regime"] = 0

apple["Signal"] = np.sign(apple["Regime"] - apple["Regime"].shift(1))

# Restore original regime data

apple.ix[-1,"Regime"] = regime_orig

apple.tail()

apple["Signal"].plot(ylim =(-2,2))

apple["Signal"].value_counts()

0.0 1637

-1.0 21

1.0 20

name: Signal,dtype: int64

我们会买入苹果公司的股票20次，抛出21次 （原文数字跟代码结果不符，译文根据代码结果更正）。如果我们只选了苹果公司的股票，六年内只有21次交易发生。如果每次多头转空头的时候我们都采取行动，我们将会参与21次交易。（请记住交易次数不是越多越好，毕竟交易不是免费的）

你也许注意到了这个系统不是很稳定。快速平均线在慢速平均线之上就激发交易，即使这个状态只是短短一瞬，这样会导致交易马上终止（这样并不好因为现实中每次交易都要付费，这个费用会很快消耗掉收益）。同时所有的牛市瞬间转为熊市，如果你允许同时押熊市和牛市，那就会出现每次交易结束就自动激发另一场押相反方向交易的诡异情况。更好的系统会要求有更多的证据来证明市场的发展方向，但是这里我们不去追究那个细节。

下面我们来看看每次买入卖出时候的股票价格。

apple.loc[apple["Signal"] ==1,"Close"]

Date

2010-03-16 224.449997

2010-06-18 274.070011

2010-09-20 283.230007

2011-05-12 346.569988

2011-07-14 357.770004

2011-12-28 402.640003

2012-06-25 570.770020

2013-05-17 433.260010

2013-07-31 452.529984

2013-10-16 501.110001

2014-03-26 539.779991

2014-04-25 571.939980

2014-08-18 99.160004

2014-10-28 106.739998

2015-02-05 119.940002

2015-04-28 130.559998

2015-10-27 114.550003

2016-03-11 102.260002

2016-07-01 95.889999

2016-07-25 97.339996

name: Close,dtype: float64

apple.loc[apple["Signal"] ==-1,"Close"]

Date

2010-06-11 253.509995

2010-07-22 259.020000

2011-03-30 348.630009

2011-03-31 348.510006

2011-05-27 337.409992

2011-11-17 377.410000

2012-05-09 569.180023

2012-10-17 644.610001

2013-06-26 398.069992

2013-10-03 483.409996

2014-01-28 506.499977

2014-04-22 531.700020

2014-06-11 93.860001

2014-10-17 97.669998

2015-01-05 106.250000

2015-04-16 126.169998

2015-06-25 127.500000

2015-12-18 106.029999

2016-05-05 93.239998

2016-07-08 96.680000

2016-09-01 106.730003

name: Close,dtype: float64

# Create a DataFrame with Trades,including the price at the Trade and the regime under which the Trade is made.

apple_signals = pd.concat([

pd.DataFrame({"Price": apple.loc[apple["Signal"] == 1,"Close"],

"Regime": apple.loc[apple["Signal"] == 1,"Regime"],

"Signal": "Buy"}),

pd.DataFrame({"Price": apple.loc[apple["Signal"] == -1,

"Regime": apple.loc[apple["Signal"] == -1,

"Signal": "Sell"}),

])

apple_signals.sort_index(inplace = True)

apple_signals

# Let's see the profitability of long Trades

apple_long_profits = pd.DataFrame({

"Price": apple_signals.loc[(apple_signals["Signal"] == "Buy") &

apple_signals["Regime"] == 1,"Price"],

"Profit": pd.SerIEs(apple_signals["Price"] - apple_signals["Price"].shift(1)).loc[

apple_signals.loc[(apple_signals["Signal"].shift(1) == "Buy") & (apple_signals["Regime"].shift(1) == 1)].index

].toList(),

"End Date": apple_signals["Price"].loc[

apple_signals.loc[(apple_signals["Signal"].shift(1) == "Buy") & (apple_signals["Regime"].shift(1) == 1)].index

].index

})

apple_long_profits

从上表可以看出2013年5月17日那天苹果公司股票价格大跌，我们的系统会表现很差。但是那个价格下降不是因为苹果遇到了什么大危机，而仅仅是一次分股。由于分红不如分股那么显著，这也许会影响系统行为。

# Let's see the result over the whole period for which we have Apple data

pandas_candlestick_ohlc(apple,stick = 45,otherserIEs = ["20d","50d","200d"])

我们不希望我们的交易系统的表现受到分红和分股的影响。一个解决方案是利用历史的分红分股数据来设计交易系统，这些数据可以真实地反映股市的行为从而帮助我们找到最佳解决方案，但是这个方法要更复杂一些。另一个方案就是根据分红和分股来调整股票的价格。

雅虎财经只提供调整之后的股票闭市价格，不过这些对于我们调整开市，高价和低价已经足够了。调整闭市股价是这样实现的：

让我们回到开始，先调整股票价格，然后再来评价我们的交易系统。

def ohlc_adj(dat):

"""

:param dat: pandas DataFrame with stock data,including "Open","High","Low","Close",and "Adj Close",with "Adj Close" containing adjusted closing prices

:return: pandas DataFrame with adjusted stock data

This function adjusts stock data for splits,divIDends,etc.,returning a data frame with

"Open","Low" and "Close" columns. The input DataFrame is similar to that returned

by pandas Yahoo! Finance API.

"""

return pd.DataFrame({"Open": dat["Open"] * dat["Adj Close"] / dat["Close"],

"High": dat["High"] * dat["Adj Close"] / dat["Close"],

"Low": dat["Low"] * dat["Adj Close"] / dat["Close"],

"Close": dat["Adj Close"]})

apple_adj = ohlc_adj(apple)

# This next code repeats all the earlIEr analysis we dID on the adjusted data

apple_adj["20d"] = np.round(apple_adj["Close"].rolling(window = 20,center =False).mean(),2)

apple_adj["50d"] = np.round(apple_adj["Close"].rolling(window = 50,2)

apple_adj["200d"] = np.round(apple_adj["Close"].rolling(window = 200,2)

apple_adj['20d-50d'] = apple_adj['20d'] - apple_adj['50d']

# np.where() is a vectorized if-else function,and the other passed if it does not

apple_adj["Regime"] = np.where(apple_adj['20d-50d'] > 0,the second argument is apple["Regime"]

apple_adj["Regime"] = np.where(apple_adj['20d-50d'] < 0,apple_adj["Regime"])

# To ensure that all Trades close out,I temporarily change the regime of the last row to 0

regime_orig = apple_adj.ix[-1,"Regime"]

apple_adj.ix[-1,"Regime"] = 0

apple_adj["Signal"] = np.sign(apple_adj["Regime"] - apple_adj["Regime"].shift(1))

# Restore original regime data

apple_adj.ix[-1,"Regime"] = regime_orig

# Create a DataFrame with Trades,including the price at the Trade and the regime under which the Trade is made.

apple_adj_signals = pd.concat([

pd.DataFrame({"Price": apple_adj.loc[apple_adj["Signal"] == 1,

"Regime": apple_adj.loc[apple_adj["Signal"] == 1,

pd.DataFrame({"Price": apple_adj.loc[apple_adj["Signal"] == -1,

"Regime": apple_adj.loc[apple_adj["Signal"] == -1,

])

apple_adj_signals.sort_index(inplace = True)

apple_adj_long_profits = pd.DataFrame({

"Price": apple_adj_signals.loc[(apple_adj_signals["Signal"] == "Buy") &

apple_adj_signals["Regime"] == 1,

"Profit": pd.SerIEs(apple_adj_signals["Price"] - apple_adj_signals["Price"].shift(1)).loc[

apple_adj_signals.loc[(apple_adj_signals["Signal"].shift(1) == "Buy") & (apple_adj_signals["Regime"].shift(1) ==1)].index

].toList(),

"End Date": apple_adj_signals["Price"].loc[

apple_adj_signals.loc[(apple_adj_signals["Signal"].shift(1) == "Buy") & (apple_adj_signals["Regime"].shift(1) ==1)].index

].index

})

pandas_candlestick_ohlc(apple_adj,"200d"])

apple_adj_long_profits

可以看到根据分红和分股调整之后的价格图变得很不一样了。之后的分析我们都会用到这个调整之后的数据。

假设我们在股市有一百万，让我们来看看根据下面的条件，我们的系统会如何反应：

每次用总额的10%来进行交易 退出头寸如果亏损达到了交易额的20%

模拟的时候要记住：

每次交易有100支股票 我们的避损规则是当股票价格下降到一定数值时就抛出。我们需要检查这段时间内的低价是否低到可以出发避损规则。现实中除非我们买入看空期权，我们无法保证我们能以设定低值价格卖出股票。这里为了简洁我们将设定值作为卖出值。 每次交易都会付给中介一定的佣金。这里我们没有考虑这个。

下面的代码演示了如何实现回溯测试：

# We need to get the low of the price during each Trade.

Tradeperiods =pd.DataFrame({"Start": apple_adj_long_profits.index,

"End": apple_adj_long_profits["End Date"]})

apple_adj_long_profits["Low"] =Tradeperiods.apply(lambdax: min(apple_adj.loc[x["Start"]:x["End"],"Low"]),axis =1)

apple_adj_long_profits

# Now we have all the information needed to simulate this strategy in apple_adj_long_profits

cash =1000000

apple_backtest =pd.DataFrame({"Start Port. Value": [],

"End Port. Value": [],

"End Date": [],

"Shares": [],

"Share Price": [],

"Trade Value": [],

"Profit per Share": [],

"Total Profit": [],

"Stop-Loss Triggered": []})

port_value =.1# Max proportion of portfolio bet on any Trade

batch =100# Number of shares bought per batch

stoploss =.2# % of Trade loss that would trigger a stoploss

forindex,row inapple_adj_long_profits.iterrows():

batches =np.floor(cash *port_value) //np.ceil(batch *row["Price"]) # Maximum number of batches of stocks invested in

Trade_val =batches *batch *row["Price"] # How much money is put on the line with each Trade

ifrow["Low"] < (1-stoploss) *row["Price"]: # Account for the stop-loss

share_profit =np.round((1-stoploss) *row["Price"],2)

stop_trig =True

else:

share_profit =row["Profit"]

stop_trig =False

profit =share_profit *batches *batch # Compute profits

# Add a row to the backtest data frame containing the results of the Trade

apple_backtest =apple_backtest.append(pd.DataFrame({

"Start Port. Value": cash,

"End Port. Value": cash +profit,

"End Date": row["End Date"],

"Shares": batch *batches,

"Share Price": row["Price"],

"Trade Value": Trade_val,

"Profit per Share": share_profit,

"Total Profit": profit,

"Stop-Loss Triggered": stop_trig

},index =[index]))

cash =max(0,cash +profit)

apple_backtest

apple_backtest["End Port. Value"].plot()

我们的财产总额六年增加了10%。考虑到每次交易额只有总额的10%，这个成绩不算差。

同时我们也注意到这个策略并没有引发停止损失委托。这意味着我们可以不需要它么？这个难说。毕竟这个激发事件完全取决于我们的设定值。

停止损失委托是被自动激活的，它并不会考虑股市整体走势。也就是说不论是股市真正的走低还是暂时的波动都会激发停止损失委托。而后者是我们需要注意的因为在现实中，由价格波动激发停止损失委托不仅让你支出一笔交易费用，同时还无法保证最终的卖出价格是你设定的价格。

下面的链接分别支持和反对使用停止损失委托，但是之后的内容我不会要求我们的回溯测试系统使用它。这样可以简化系统，但不是很符合实际（我相信工业系统应该有停止损失委托）。

现实中我们不会只用总额的10%去押一支股票而是投资多种股票。在给定的时间可以跟不同公司同时交易，而且大部分财产应该在股票上，而不是现金。现在我们开始投资多支股票 （原文是stops，感觉是typo，译文按照stocks翻译），并且在两条移动平均线交叉的时候退市（不使用止损）。我们需要改变回溯测试的代码。我们会用一个pandas的DataFrame来存储所有股票的买卖，上一层的循环也需要记录更多的信息。

下面的函数用于产生买卖订单，以及另一回溯测试函数。

代码过长，微信阅读体验不好，可点击「阅读原文」在网页版查看

signals =ma_crossover_orders([("AAPL",ohlc_adj(apple)),

("MSFT",ohlc_adj(microsoft)),

("GOOG",ohlc_adj(Google)),

("FB",ohlc_adj(facebook)),

("TWTR",ohlc_adj(twitter)),

("NFLX",ohlc_adj(netflix)),

("AMZN",ohlc_adj(amazon)),

("YHOO",ohlc_adj(yahoo)),

("SNY",

("NTDOY",ohlc_adj(nintendo)),

("IBM",ohlc_adj(ibm)),

("HPQ",ohlc_adj(hp))],

fast =20,slow =50)

signals

475 rows × 3 columns

bk =backtest(signals,1000000)

bk

475 rows × 9 columns

bk["Portfolio Value"].groupby(level =0).apply(lambdax: x[-1]).plot()

更为现实的投资组合可以投资任何12支股票而达到100%的收益。这个看上去不错，但是我们可以做得更好。

基准分析法

基准分析法可以分析交易策略效率的好坏。所谓基准分析，就是将策略和其他（著名）策略进行比较从而评价该策略的表现好坏。

每次你评价交易系统的时候，都要跟买入持有策略（SPY）进行比较。除了一些信托基金和少数投资经理没有使用它，该策略在大多时候都是无敌的。有效市场假说强调没有人能战胜股票市场，所以每个人都应该购入指数基金，因为它能反应整个市场的构成。SPY是一个交易型开放式指数基金（一种可以像股票一样交易的信托基金），它的价格有效反映了S&P 500中的股票价格。买入并持有SPY，说明你可以有效地匹配市场回报率而不是战胜它。

下面是SPY的数据，让我们看看简单买入持有SPY能得到的回报：

spyder =web.DataReader("SPY","yahoo",start,end)

spyder.iloc[[0,-1],:]

batches =1000000//np.ceil(100*spyder.ix[0,"Adj Close"]) # Maximum number of batches of stocks invested in

Trade_val =batches *batch *spyder.ix[0,"Adj Close"] # How much money is used to buy SPY

final_val =batches *batch *spyder.ix[-1,"Adj Close"] +(1000000-Trade_val) # Final value of the portfolio

final_val

2180977.0

# We see that the buy-and-hold strategy beats the strategy we developed earlIEr. I would also like to see a plot.

ax_bench =(spyder["Adj Close"] /spyder.ix[0,"Adj Close"]).plot(label ="SPY")

ax_bench =(bk["Portfolio Value"].groupby(level =0).apply(lambdax: x[-1]) /1000000).plot(ax =ax_bench,label ="Portfolio")

ax_bench.legend(ax_bench.get_lines(),[l.get_label() forl inax_bench.get_lines()],loc ='best')

ax_bench

买入持有SPY比我们当前的交易系统好——我们的系统还没有考虑不菲的交易费用。考虑到机会成本和该策略的消耗，我们不应该用它。

怎样才能改进我们的系统呢？对于初学者来尽量多样化是一个选择。目前我们所有的股票都来自技术公司，这意味着技术型公司的不景气会反映在我们的投资组合上。我们应该设计一个可以利用空头头寸和熊市的系统，这样不管市场如何变动，我们都可以盈利。我们也可以寻求更好的方法预测股票的最高期望价格。但是不论如何我们都需要做得比SPY更好，不然由于我们的系统会自带机会成本，是没用的。

其他的基准策略也是存在的。如果我们的系统比“买入持有SPY”更好，我们可以进一步跟其他的系统比较，例如：

（我最初在这里接触到这些策略）基本准则仍然是：不要使用一个复杂的，包含大量交易的系统如果它赢不了一个简单的交易不频繁的指数基金模型。（事实上这个标准挺难实现的）

最后要强调的是，假设你的交易系统在回溯测试中打败了所有的基准系统，也不意味着它能够准确地预测未来。因为回溯测试容易过拟合，它不能用于预测未来。

结论

虽然讲座最后的结论不是那么乐观，但记住有效市场理论也有缺陷。我个人的观点是当交易更多依赖于算法的时候，就更难战胜市场。有一个说法是：信托基金都不太可能战胜市场，你的系统能战胜市场仅仅是一个可能性而已。（当然信托基金表现很差的原因是收费太高，而指数基金不存在这个问题。）

本讲座只简单地说明了一种基于移动平均的交易策略。还有许多别的交易策略这里并没有提到。而且我们也没有深入探讨空头股票和货币交易。特别是股票期权有很多东西可以讲，它也提供了不同的方法来预测股票的走向。你可以在Derivatives Analytics with Python: Data Analysis,Models,Simulation,Calibration and Hedging书中读到更多的相关内容。（犹他大学的图书馆有这本书）

另一个资源是O’Reilly出的Python for Finance，犹他大学的图书馆里也有。

记住在股票里面亏钱是很正常的，同样股市也能提供其他方法无法提供的高回报，每一个投资策略都应该是经过深思熟虑的。这个讲座旨在抛砖引玉，希望同学们自己进一步探讨这个话题。

作业

问题1

建立一个基于移动平均的交易系统（不需要止损条件）。选择15支2010年1月1日之前上市的股票，利用回溯测试检验你的 系统，并且SPY基准作比较，你的系统能战胜市场吗？

问题2

在现实中每一笔交易都要支付一笔佣金。弄明白如何计算佣金，然后修改你的backtes()函数，使之能够计算不同的佣金模式（固定费用，按比例收费等等）。

我们现在的移动平均交汇点分析系统在两条平均线交叉的时候触发交易。修改系统令其更准确：

当你完成修改之后，重复问题1，使用一个真实的佣金策略（从交易所查）来模拟你的系统，同时要求移动平均差异达到一定的移动标准差再激发交易。

问题3

我们的交易系统无法处理空头股票。空头买卖的复杂性在于损失是没有下限的（多头头寸的最大损失等于购入股票的总价格）。学习如何处理空头头寸，然后修改backtest()使其能够处理空头交易。思考要如何实现空头交易，包括允许多少空头交易？在进行其他交易的时候如何处理空头交易？提示：空头交易的量在函数中可以用一个负数来表示。

完成之后重复问题1，也可以同时考虑问题2中提到的因素。

总结

以上是内存溢出为你收集整理的用 Python 做股市数据分析！股民必备技能哦！还不get去？全部内容，希望文章能够帮你解决用 Python 做股市数据分析！股民必备技能哦！还不get去？所遇到的程序开发问题。

如果觉得内存溢出网站内容还不错，欢迎将内存溢出网站推荐给程序员好友。