用Python做股市数据分析（二）

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

apple["Signal"].value_counts()

 0.0    1637
-1.0      21
 1.0      20
Name: Signal, dtype: int64

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, "Close"],
                     "Regime": apple.loc[apple["Signal"] == -1, "Regime"],
                     "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

#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"])

defohlc_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", "High", "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, center = False).mean(), 2)
apple_adj["200d"] = np.round(apple_adj["Close"].rolling(window = 200, center = False).mean(), 2)
apple_adj['20d-50d'] = apple_adj['20d'] - apple_adj['50d']
#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_adj["Regime"] = np.where(apple_adj['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_adj["Regime"] = np.where(apple_adj['20d-50d'] < 0, -1, 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, "Close"],
                     "Regime": apple_adj.loc[apple_adj["Signal"] == 1, "Regime"],
                     "Signal": "Buy"}),
        pd.DataFrame({"Price": apple_adj.loc[apple_adj["Signal"] == -1, "Close"],
                     "Regime": apple_adj.loc[apple_adj["Signal"] == -1, "Regime"],
                     "Signal": "Sell"}),
    ])
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, "Price"],
        "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, stick = 45, otherseries = ["20d", "50d", "200d"])

apple_adj_long_profits

#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()

defma_crossover_orders(stocks, fast, slow):
    """
    :param stocks: A list of tuples, the first argument in each tuple being a string containing the ticker symbol of each stock (or however you want the stock represented, so long as it's unique), and the second being a pandas DataFrame containing the stocks, with a "Close" column and indexing by date (like the data frames returned by the Yahoo! Finance API)
    :param fast: Integer for the number of days used in the fast moving average
    :param slow: Integer for the number of days used in the slow moving average
    :return: pandas DataFrame containing stock orders
    This function takes a list of stocks and determines when each stock would be bought or sold depending on a moving average crossover strategy, returning a data frame with information about when the stocks in the portfolio are bought or sold according to the strategy
    """
    fast_str =str(fast) +'d'
    slow_str =str(slow) +'d'
    ma_diff_str =fast_str +'-'+slow_str
    trades =pd.DataFrame({"Price": [], "Regime": [], "Signal": []})
    fors instocks:
        #Get the moving averages, both fast and slow, along with the difference in the moving averages
        s[1][fast_str] =np.round(s[1]["Close"].rolling(window =fast, center =False).mean(), 2)
        s[1][slow_str] =np.round(s[1]["Close"].rolling(window =slow, center =False).mean(), 2)
        s[1][ma_diff_str] =s[1][fast_str] -s[1][slow_str]
        #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
        s[1]["Regime"] =np.where(s[1][ma_diff_str] > 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"]
        s[1]["Regime"] =np.where(s[1][ma_diff_str] < 0, -1, s[1]["Regime"])
        #To ensure that all trades close out, I temporarily change the regime of the last row to 0
        regime_orig =s[1].ix[-1, "Regime"]
        s[1].ix[-1, "Regime"] =0
        s[1]["Signal"] =np.sign(s[1]["Regime"] -s[1]["Regime"].shift(1))
        #Restore original regime data
        s[1].ix[-1, "Regime"] =regime_orig
        #Get signals
        signals =pd.concat([
            pd.DataFrame({"Price": s[1].loc[s[1]["Signal"] ==1, "Close"],
                         "Regime": s[1].loc[s[1]["Signal"] ==1, "Regime"],
                         "Signal": "Buy"}),
            pd.DataFrame({"Price": s[1].loc[s[1]["Signal"] ==-1, "Close"],
                         "Regime": s[1].loc[s[1]["Signal"] ==-1, "Regime"],
                         "Signal": "Sell"}),
        ])
        signals.index =pd.MultiIndex.from_product([signals.index, [s[0]]], names =["Date", "Symbol"])
        trades =trades.append(signals)
    trades.sort_index(inplace =True)
    trades.index =pd.MultiIndex.from_tuples(trades.index, names =["Date", "Symbol"])
    returntrades
defbacktest(signals, cash, port_value =.1, batch =100):
    """
    :param signals: pandas DataFrame containing buy and sell signals with stock prices and symbols, like that returned by ma_crossover_orders
    :param cash: integer for starting cash value
    :param port_value: maximum proportion of portfolio to risk on any single trade
    :param batch: Trading batch sizes
    :return: pandas DataFrame with backtesting results
    This function backtests strategies, with the signals generated by the strategies being passed in the signals DataFrame. A fictitious portfolio is simulated and the returns generated by this portfolio are reported.
    """
    SYMBOL =1#Constant for which element in index represents symbol
    portfolio =dict()    #Will contain how many stocks are in the portfolio for a given symbol
    port_prices =dict()  #Tracks old trade prices for determining profits
    #Dataframe that will contain backtesting report
    results =pd.DataFrame({"Start Cash": [],
                            "End Cash": [],
                            "Portfolio Value": [],
                            "Type": [],
                            "Shares": [],
                            "Share Price": [],
                            "Trade Value": [],
                            "Profit per Share": [],
                            "Total Profit": []})
    forindex, row insignals.iterrows():
        #These first few lines are done for any trade
        shares =portfolio.setdefault(index[SYMBOL], 0)
        trade_val =0
        batches =0
        cash_change =row["Price"] *shares   #Shares could potentially be a positive or negative number (cash_change will be added in the end; negative shares indicate a short)
        portfolio[index[SYMBOL]] =0#For a given symbol, a position is effectively cleared

        old_price =port_prices.setdefault(index[SYMBOL], row["Price"])
        portfolio_val =0
        forkey, val inportfolio.items():
            portfolio_val +=val *port_prices[key]
        ifrow["Signal"] =="Buy"androw["Regime"] ==1:  #Entering a long position
            batches =np.floor((portfolio_val +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
            cash_change -=trade_val  #We are buying shares so cash will go down
            portfolio[index[SYMBOL]] =batches *batch  #Recording how many shares are currently invested in the stock
            port_prices[index[SYMBOL]] =row["Price"]   #Record price
            old_price =row["Price"]
        elifrow["Signal"] =="Sell"androw["Regime"] ==-1: #Entering a short
            pass
            #Do nothing; can we provide a method for shorting the market?
        #else:
            #raise ValueError("I don't know what to do with signal " + row["Signal"])

        pprofit =row["Price"] -old_price   #Compute profit per share; old_price is set in such a way that entering a position results in a profit of zero
        #Update report
        results =results.append(pd.DataFrame({
                "Start Cash": cash,
                "End Cash": cash +cash_change,
                "Portfolio Value": cash +cash_change +portfolio_val +trade_val,
                "Type": row["Signal"],
                "Shares": batch *batches,
                "Share Price": row["Price"],
                "Trade Value": abs(cash_change),
                "Profit per Share": pprofit,
                "Total Profit": batches *batch *pprofit
            }, index =[index]))
        cash +=cash_change  #Final change to cash balance

    results.sort_index(inplace =True)
    results.index =pd.MultiIndex.from_tuples(results.index, names =["Date", "Symbol"])
    returnresults
#Get more stocks
microsoft =web.DataReader("MSFT", "yahoo", start, end)
google =web.DataReader("GOOG", "yahoo", start, end)
facebook =web.DataReader("FB", "yahoo", start, end)
twitter =web.DataReader("TWTR", "yahoo", start, end)
netflix =web.DataReader("NFLX", "yahoo", start, end)
amazon =web.DataReader("AMZN", "yahoo", start, end)
yahoo =web.DataReader("YHOO", "yahoo", start, end)
sony =web.DataReader("SNY", "yahoo", start, end)
nintendo =web.DataReader("NTDOY", "yahoo", start, end)
ibm =web.DataReader("IBM", "yahoo", start, end)
hp =web.DataReader("HPQ", "yahoo", start, end)

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",   ohlc_adj(yahoo)),
                              ("NTDOY", ohlc_adj(nintendo)),
                              ("IBM",   ohlc_adj(ibm)),
                              ("HPQ",   ohlc_adj(hp))],
                            fast =20, slow =50)
signals

bk =backtest(signals, 1000000)
bk

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

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

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

spyder =web.DataReader("SPY", "yahoo", start, end)
spyder.iloc[[0,-1],:]