- \n
- Getting historical pricing data to use for visualization via the
yfinance<\/code> library<\/li>\n- Two methods of calculating moving averages in Python<\/li>\n
- Using
pandas_ta<\/code> library to create groupings of technical indicators to apply at broader scales<\/li>\n- Considerations for multiprocessing of large amounts of data and indicators like moving averages<\/li>\n
- Creating candlestick charts in
Plotly<\/code> with overlaid signal lines for simple and exponential moving averages<\/li>\n- Interpreting the SMA and EMA crossover events as trading signals to indicate shifts in price momentum<\/li>\n<\/ul>\n
Moving Averages 101<\/h2>\n
Before we get into how to calculate moving averages in Python let us first discuss what they are. Moving averages are measures of momentum over a series of observed values. These measures are commonly made across a subset of values within a larger set. This subset, known as the lookback period, offers different functional insights based on its value.<\/p>\n
There are a number of common moving average indicators each of which has variations utilizing several common lookback periods. The following are the most common among stock-trading:<\/p>\n
- \n
- Simple Moving Average (SMA)<\/strong>: Represents the mean value across a period of n-previous observations. Common lookback periods include 50, 100, and 200-period trailing values.<\/li>\n
- Weighted Moving Average (WMA)<\/strong>: Represents a weighted mean across a period of n-pervious observations where each observation is given a different weight. Used as the basis for several other moving averages.<\/li>\n
- Exponential Moving Average (EMA)<\/strong>: Represents a weighted mean across a period of n-previous observations where values closest to the most recent are given exponentially<\/em> larger consideration.<\/li>\n<\/ul>\n
Moving averages not only come in a range of different lookback window variations but can also be used in conjunction with other statistical methods. For example, technical analysts use the Bollinger Bands which incorporate a simple moving average that integrates a 9-21 day lookback window period. Check out our article on Moving Averages<\/a><\/em> for more information.<\/p>\n
Calculating Moving Averages in Python<\/h2>\n
Python has emerged as the leading programming language for all things data. This includes machine learning, statistics (sorry, R), and algorithmic trading. As with any language, Python can use native syntax to calculate moving averages.<\/p>\n
These implementations can be tedious, under-optimized, and hard to scale across large datasets. Fortunately, libraries like Pandas make implementing technical indicators a breeze. Let’s take a look at two approaches, both using Pandas:<\/p>\n
Method 1: DataFrames & Native Pandas Functions<\/h3>\n
Pandas is a powerful computing library. It comes with a lot of optimized functions to absolutely\u00a0churn<\/em> through data. It doesn’t offer explicit support for some more complex indicators but moving averages are well within its ability. Consider the following approach for calculating the simple moving average using Pandas:<\/p>\n
# import yfinance to get pricing data\r\nimport yfinance as yf\r\n\r\n# Get 1-yr price history for $NVDA\r\nnvda = yf.Ticker('NVDA')\r\ndf = nvda.history(period='1y')[['Open', 'High', 'Low', 'Close', 'Volume']] # return is pandas DataFrame object\r\n\r\n# Result\r\n Open High Low Close Volume\r\nDate \r\n2020-07-28 103.621322 103.698731 101.973248 102.035675 27163600\r\n2020-07-29 103.786129 105.039660 103.349140 104.532753 28450800\r\n2020-07-30 103.628814 106.105921 102.832245 106.016022 30888000\r\n2020-07-31 105.509108 107.539235 104.208132 106.023506 38608000\r\n2020-08-03 107.199633 110.857861 107.027333 109.973892 41272000\r\n... ... ... ... ... ...\r\n2021-07-21 188.820007 195.270004 187.419998 194.100006 37101700\r\n2021-07-22 196.419998 198.869995 192.759995 195.940002 32382600\r\n2021-07-23 196.559998 197.000000 192.500000 195.580002 19542900\r\n2021-07-26 193.110001 194.419998 189.139999 192.940002 20373800\r\n2021-07-27 192.649994 196.199997 187.410004 192.080002 23994571\r\n\r\n[252 rows x 5 columns]\r\n<\/pre>\nWhat we’ve done here is use the yfinance<\/a> library to download historic pricing data from the finance.yahoo.com public API server. The is returned as a pandas DataFrame object. Note that only the OHLCV columns were specified. By default, a
splits<\/code> anddividends<\/code> column are also returned. Let’s take a look at how to apply a simple moving average to this data:<\/p>\n# Add a simple moving average\r\ndf['SMA_10'] = df['Close'].rolling(window=10).mean()\r\n\r\n# print the first 15 rows of data\r\nprint(df.head(15))\r\n\r\n Open High ... Volume SMA_10\r\nDate ... \r\n2020-07-28 103.621322 103.698731 ... 27163600 NaN\r\n2020-07-29 103.786129 105.039660 ... 28450800 NaN\r\n2020-07-30 103.628814 106.105921 ... 30888000 NaN\r\n2020-07-31 105.509108 107.539235 ... 38608000 NaN\r\n2020-08-03 107.199633 110.857861 ... 41272000 NaN\r\n2020-08-04 110.370919 112.146339 ... 31033600 NaN\r\n2020-08-05 112.308666 113.584670 ... 24992400 NaN\r\n2020-08-06 113.364923 113.447331 ... 24431600 NaN\r\n2020-08-07 112.992859 114.913114 ... 34251600 NaN\r\n2020-08-10 113.210097 113.949231 ... 42779600 109.007021\r\n2020-08-11 110.608158 111.237419 ... 35451200 109.640780\r\n2020-08-12 109.779123 114.536057 ... 46441200 110.614391\r\n2020-08-13 115.325137 117.080583 ... 37446000 111.442423\r\n2020-08-14 115.165314 116.910770 ... 36643600 112.390564\r\n2020-08-17 118.374052 123.952535 ... 62130000 113.715763\r\n\r\n[15 rows x 6 columns]\r\n<\/pre>\n
In the first line of code, we specify the average of the previous 10 periods of the
Close<\/code> column values (inclusive of current) to be used in calculating a rolling mean<\/em>. This makes use of the pandas’ DataFrame rolling<\/a> method. Note theNaN<\/code> value seen in the first 9 rows for the newSMA_10<\/code> column. These exist because there were not enough previous data to make a calculation.<\/p>\nMethod 2: Using the pandas_ta Library<\/h3>\n
Pandas is a beast when it comes to scientific calculations. It offers a wide array of statistical and mathematical functions that can be used to calculate just about anything in a wildly efficient manner.<\/p>\n
Pandas isn’t designed for calculating technical indicators and algorithmic traders may find its syntax cumbersome.\u00a0 Fortunately, the pandas_ta library<\/a> integrates with
DataFrames<\/code> natively and makes adding technical indicators a breeze. Consider the following code that adds the 5, 10, and 20-period Simple Moving Average calculated from the daily closing price:<\/p>\n# import required library\r\nimport pandas_ta as ta\r\n\r\n# Add indicators, using data from before\r\ndf.ta.sma(close='close', length=5, append=True)\r\ndf.ta.sma(close='close', length=10, append=True)\r\ndf.ta.sma(close='close', length=20, append=True)\r\n\r\n# View Result\r\n open high low close volume \\\r\ndate \r\n2020-07-28 103.621322 103.698731 101.973248 102.035675 27163600 \r\n2020-07-29 103.786129 105.039660 103.349140 104.532753 28450800 \r\n2020-07-30 103.628814 106.105921 102.832245 106.016022 30888000 \r\n2020-07-31 105.509108 107.539235 104.208132 106.023506 38608000 \r\n2020-08-03 107.199633 110.857861 107.027333 109.973892 41272000 \r\n... ... ... ... ... ... \r\n2021-07-21 188.820007 195.270004 187.419998 194.100006 37101700 \r\n2021-07-22 196.419998 198.869995 192.759995 195.940002 32382600 \r\n2021-07-23 196.559998 197.000000 192.500000 195.580002 19542900 \r\n2021-07-26 193.110001 194.419998 189.139999 192.940002 20373800 \r\n2021-07-27 192.649994 196.199997 187.410004 192.080002 23994571 \r\n\r\n SMA_5 SMA_10 SMA_20 \r\ndate \r\n2020-07-28 NaN NaN NaN \r\n2020-07-29 NaN NaN NaN \r\n2020-07-30 NaN NaN NaN \r\n2020-07-31 NaN NaN NaN \r\n2020-08-03 105.716370 NaN NaN \r\n... ... ... ... \r\n2021-07-21 187.858002 194.486000 196.781624 \r\n2021-07-22 189.113501 194.177251 197.049999 \r\n2021-07-23 191.907501 193.685001 197.226250 \r\n2021-07-26 192.936002 192.466501 197.357750 \r\n2021-07-27 194.128003 191.424501 196.969250 \r\n<\/pre>\n
Here we’ve used the pandas_ta native integration with Pandas
DataFrames<\/code> via the DataFrame.ta method. Using this allows us to easily add the simple moving averages via thepandas_ta sma<\/code> function. Pay close attention to our use of theappend=True<\/code> argument. Without this, our newly-calculated indicator won’t be added to our existingDataFrame<\/code> and be returned as aPandas.core.Series<\/code> object. This is pretty convenient but becomes a syntactic nightmare when adding lots of indicators. Fortunately, pandas_ta has a novel Strategy class to help facilitate more modular code<\/a>. Consider the following:<\/p>\n# Create a pandas_ta strategy\r\nmoving_averages = ta.Strategy(\r\n name=\"SMA_5_10_20\",\r\n ta=[\r\n {\"kind\": \"sma\", \"length\": 5},\r\n {\"kind\": \"sma\", \"length\": 10},\r\n {\"kind\": \"sma\", \"length\": 20}\r\n ]\r\n)\r\n\r\n# Disable multiprocessing\r\ndf.ta.cores = 0\r\n\r\n# Add bulk indicators\r\ndf.ta.strategy(moving_averages, append=True)\r\n\r\n open high low close volume \\\r\ndate \r\n2020-07-28 103.621322 103.698731 101.973248 102.035675 27163600 \r\n2020-07-29 103.786129 105.039660 103.349140 104.532753 28450800 \r\n2020-07-30 103.628814 106.105921 102.832245 106.016022 30888000 \r\n2020-07-31 105.509108 107.539235 104.208132 106.023506 38608000 \r\n2020-08-03 107.199633 110.857861 107.027333 109.973892 41272000 \r\n... ... ... ... ... ... \r\n2021-07-21 188.820007 195.270004 187.419998 194.100006 37101700 \r\n2021-07-22 196.419998 198.869995 192.759995 195.940002 32382600 \r\n2021-07-23 196.559998 197.000000 192.500000 195.580002 19542900 \r\n2021-07-26 193.110001 194.419998 189.139999 192.940002 20373800 \r\n2021-07-27 192.649994 196.199997 187.410004 192.080002 23994571 \r\n\r\n SMA_5 SMA_10 SMA_20 \r\ndate \r\n2020-07-28 NaN NaN NaN \r\n2020-07-29 NaN NaN NaN \r\n2020-07-30 NaN NaN NaN \r\n2020-07-31 NaN NaN NaN \r\n2020-08-03 105.716370 NaN NaN \r\n... ... ... ... \r\n2021-07-21 187.858002 194.486000 196.781624 \r\n2021-07-22 189.113501 194.177251 197.049999 \r\n2021-07-23 191.907501 193.685001 197.226250 \r\n2021-07-26 192.936002 192.466501 197.357750 \r\n2021-07-27 194.128003 191.424501 196.969250 \r\n\r\n[252 rows x 8 columns]<\/pre>\nHere we see a\u00a0very<\/em> reusable approach at applying moving averages to DataFrames via the pandas_ta library. Take note of the
df.ta.cores = 0<\/code> line. By default, pandas_ta will use multiprocessing<\/a> to apply indicators in bulk.<\/p>\nThis necessitates the calling of code via the if
__name__ == \"__main__\"<\/code> convention to support Windows systems<\/a>. To leverage the power of multiprocessing for the addition of many indicators, simply call the function from within the main process:<\/p>\nif __name__ == '__main__':\r\n \r\n # Getting the data\r\n nvda = yf.Ticker('NVDA')\r\n df = nvda.history(period='1y')[['Open', 'High', 'Low', 'Close', 'Volume']]\r\n \r\n # Create a pandas_ta strategy\r\n moving_averages = ta.Strategy(\r\n name=\"SMA_5_10_20\",\r\n ta=[\r\n {\"kind\": \"sma\", \"length\": 5},\r\n {\"kind\": \"sma\", \"length\": 10},\r\n {\"kind\": \"sma\", \"length\": 20}\r\n ]\r\n )\r\n \r\n # Add bulk indicators\r\n # df.ta.cores = 0\r\n df.ta.strategy(moving_averages, append=True)<\/pre>\nWhen adding dozens of indicators it’s generally recommended to leverage the power of multiprocessing. This will speed up backtesting and data processing by orders of magnitude in many cases, especially in cases of more complex indicator calculations.<\/p>\n
Plotting Moving Averages in Python<\/h2>\n
Making the calculations for moving averages is a breeze in Python\u2014especially with the pandas_ta library. These data are perfect for integrating with larger trading strategies or developing custom machine learning models. However, DataFrames full of numbers don’t offer much in the way of visualization. Let’s take a look at how to create a visualization of some moving averages in Python using Pandas, pandas_ta, and Plotly.<\/p>\n
import pandas_ta as ta\r\nimport yfinance as yf\r\nimport plotly.graph_objects as go\r\n\r\n\r\n# Get the data\r\ndf = yf.Ticker('BTC-USD').history(period='6mo')[['Open', 'Close', 'High', 'Low', 'Volume']]\r\n\r\n# Add the indicators\r\nmoving_averages = ta.Strategy(\r\n name=\"moving indicators\",\r\n ta=[\r\n {\"kind\": \"sma\", \"length\": 10},\r\n {\"kind\": \"ema\", \"length\": 5},\r\n ]\r\n)\r\n\r\n# Disable multiprocessing, calculate averages\r\ndf.ta.cores = 0 # optional, but requires if __name__ == \"__main__\" syntax if not set to 0\r\ndf.ta.strategy(moving_averages)\r\n\r\n# Create the Plot\r\nfig = go.Figure(data=[\r\n go.Candlestick(\r\n x=df.index,\r\n open=df['open'],\r\n high=df['high'],\r\n low=df['low'],\r\n close=df['close'],\r\n increasing_line_color='#ff9900',\r\n decreasing_line_color='black',\r\n showlegend=False,\r\n ),\r\n])\r\n\r\n# Make it pretty\r\nlayout = go.Layout(\r\n plot_bgcolor='#efefef',\r\n # Font Families\r\n font_family='Monospace',\r\n font_color='#000000',\r\n font_size=20,\r\n xaxis=dict(\r\n rangeslider=dict(\r\n visible=False\r\n ))\r\n)\r\nfig.update_layout(layout)\r\n\r\n# Display (in browser by default)\r\nfig.show()<\/pre>\nThere are several things going on here.<\/p>\n
- \n
- Using the yfinance library to get pricing data for $BTC-USD for the past 6 months.<\/li>\n
- Adding two moving average indicators\u2014a 10-period SMA and 5-period EMA.<\/li>\n
- Creating a Candlestick class figure in Plotly<\/li>\n
- Updating the chart options for aesthetic purposes<\/li>\n
- Opening the result in the system default HTML viewer (Chrome, Firefox, Opera, etc.)<\/li>\n<\/ol>\n
This produces the following results:<\/p>\n
![\"btc](\"https:\/\/www.alpharithms.com\/wp-content\/uploads\/1307\/btc-usd-candlestick-chart-plotly-python-alpharithms-notitle-1024x576.jpg\" "\\"btc-usd-candlestick-chart-plotly-python-alpharithms-notitle\\"")
<\/a>Basic Candlestick chart showing the price of $BTC-USD over a period of 6 months. (click to enlarge)<\/figcaption><\/figure>\n This is pretty rad\u2014but where are the moving averages! They aren’t visible because we forgot to add them via Plotly after calculating them via pandas_ta. Fortunately, adding extra “traces” to our figure is simple using the Plotly API. Consider the following example code:<\/p>\n
...\r\n\r\n# Add the SMA 10\r\nfig.add_trace(\r\n go.Scatter(\r\n x=df.index,\r\n y=df['SMA_10'],\r\n line=dict(color='#ff9900', width=2),\r\n name='SMA_10'\r\n )\r\n)\r\n\r\n# Add the EMA 5\r\nfig.add_trace(\r\n go.Scatter(\r\n x=df.index,\r\n y=df['EMA_5'],\r\n line=dict(color='#000', width=2),\r\n name='EMA_5'\r\n )\r\n)\r\n\r\n# See things again\r\nfig.show()<\/pre>\n
This adds two “traces” to the Plotly figure\u2014the SMA 10 and EMA 5 lines. Let’s see what we have now:<\/p>\n
![\"btc](\"https:\/\/www.alpharithms.com\/wp-content\/uploads\/1307\/btc-usd-candlestick-chart-with-moving-averages-plotly-python-alpharithms-1024x576.jpg\" "\\"btc-usd-candlestick-chart-plotly-with-moving-averages-python-alpharithms\\"")
<\/a>6mo. Candlestick chart of $BTC-USD with a 10-period Simple Moving average and 5-period Exponential Moving Average. (Click to Enlarge)<\/figcaption><\/figure>\n In this visualization, we can see the 10-period simple moving average<\/strong> (yellow line) charting against the 5-period exponential moving average<\/strong> (black line.) Visualized together, we can see a shift in momentum in many areas where the EMA crosses the SMA. Given the EMA reflects a faster change in price momentum, this crossover pattern is often used as a composite technical indicator to forecast emerging price trends.<\/p>\n
Review<\/h2>\n
Moving averages are great tools for forecasting momentum shifts in observed values over a period of time. We’ve seen how Python can easily facilitate the calculation and visualization of these technical indicators in such a way as to provide valuable (and actionable) insights. On their own, moving averages smooth out volatility to reflect momentum trends.<\/p>\n
- Weighted Moving Average (WMA)<\/strong>: Represents a weighted mean across a period of n-pervious observations where each observation is given a different weight. Used as the basis for several other moving averages.<\/li>\n