Charting

Follow these steps to import the libraries that you need:

1. Import the matplotlib, mplfinance, and numpy libraries.

import matplotlib.pyplot as plt
import mplfinance
import numpy as np

2. Import, and then call, the register_matplotlib_converters method.

from pandas.plotting import register_matplotlib_converters
register_matplotlib_converters()

Get some historical market data to produce the plots. For example, to get data for a bank sector ETF and some banking companies over 2021, run:

qb = QuantBook()
tickers = ["XLF",   # Financial Select Sector SPDR Fund
           "COF",   # Capital One Financial Corporation
           "GS",    # Goldman Sachs Group, Inc.
           "JPM",   # J P Morgan Chase & Co
           "WFC"]   # Wells Fargo & Company   
symbols = [qb.add_equity(ticker, Resolution.DAILY).symbol for ticker in tickers]
history = qb.history(symbols, datetime(2021, 1, 1), datetime(2022, 1, 1))

You must import the plotting libraries and get some historical data to create candlestick charts.

In this example, we'll create a candlestick chart that shows the open, high, low, and close prices of one of the banking securities. Follow these steps to create the candlestick chart:

1. Select a Symbol.

symbol = symbols[0]

2. Slice the history DataFrame with the symbol.

data = history.loc[symbol]

3. Rename the columns.

data.columns = ['Close', 'High', 'Low', 'Open', 'Volume']

4. Call the plot method with the data, chart type, style, title, y-axis label, and figure size.

mplfinance.plot(data,
                type='candle',
                style='charles',
                title=f'{symbol.value} OHLC',
                ylabel='Price ($)',
                figratio=(15, 10))

The Jupyter Notebook displays the candlestick chart.

You must import the plotting libraries and get some historical data to create line charts.

In this example, you create a line chart that shows the closing price for one of the banking securities. Follow these steps to create the line chart:

1. Select a Symbol.

symbol = symbols[0]

2. Slice the history DataFrame with symbol and then select the close column.

data = history.loc[symbol]['close']

3. Call the plot method with a title and figure size.

data.plot(title=f"{symbol} Close Price", figsize=(15, 10));

The Jupyter Notebook displays the line plot.

You must import the plotting libraries and get some historical data to create scatter plots.

In this example, you create a scatter plot that shows the relationship between the daily returns of two banking securities. Follow these steps to create the scatter plot:

1. Select the 2 Symbols.

For example, to select the Symbols of the first 2 bank stocks, run:

symbol1 = symbols[1]
symbol2 = symbols[2]

2. Slice the history DataFrame with each Symbol and then select the close column.

close_price1 = history.loc[symbol1]['close']
close_price2 = history.loc[symbol2]['close']

3. Call the pct_change and dropna methods on each Series.

daily_returns1 = close_price1.pct_change().dropna()
daily_returns2 = close_price2.pct_change().dropna()

4. Call the polyfit method with the daily_returns1, daily_returns2, and a degree.

m, b = np.polyfit(daily_returns1, daily_returns2, deg=1)

This method call returns the slope and intercept of the ordinary least squares regression line.

5. Call the linspace method with the minimum and maximum values on the x-axis.

x = np.linspace(daily_returns1.min(), daily_returns1.max())

6. Calculate the y-axis coordinates of the regression line.

y = m*x + b

7. Call the plot method with the coordinates and color of the regression line.

plt.plot(x, y, color='red')

8. In the same cell that you called the plot method, call the scatter method with the 2 daily return series.

plt.scatter(daily_returns1, daily_returns2)

9. In the same cell that you called the scatter method, call the title, xlabel, and ylabel methods with a title and axis labels.

plt.title(f'{symbol1} vs {symbol2} daily returns Scatter Plot')
plt.xlabel(symbol1.value)
plt.ylabel(symbol2.value);

The Jupyter Notebook displays the scatter plot.

You must import the plotting libraries and get some historical data to create histograms.

In this example, you create a histogram that shows the distribution of the daily percent returns of the bank sector ETF. In addition to the bins in the histogram, you overlay a normal distribution curve for comparison. Follow these steps to create the histogram:

1. Select the Symbol.

symbol = symbols[0]

2. Slice the history DataFrame with the symbol and then select the close column.

close_prices = history.loc[symbol]['close']

3. Call the pct_change method and then call the dropna method.

daily_returns = close_prices.pct_change().dropna()

4. Call the mean and std methods.

mean = daily_returns.mean()
std = daily_returns.std()

5. Call the linspace method with the lower limit, upper limit, and number data points for the x-axis of the normal distribution curve.

x = np.linspace(-3*std, 3*std, 1000)

6. Calculate the y-axis values of the normal distribution curve.

pdf = 1/(std * np.sqrt(2*np.pi)) * np.exp(-(x-mean)**2 / (2*std**2))

7. Call the plot method with the data for the normal distribution curve.

plt.plot(x, pdf, label="Normal Distribution")

8. In the same cell that you called the plot method, call the hist method with the daily return data and the number of bins.

plt.hist(daily_returns, bins=20)

9. In the same cell that you called the hist method, call the title, xlabel, and ylabel methods with a title and the axis labels.

plt.title(f'{symbol} Return Distribution')
plt.xlabel('Daily Return')
plt.ylabel('Count');

The Jupyter Notebook displays the histogram.

You must import the plotting libraries and get some historical data to create bar charts.

In this example, you create a bar chart that shows the average daily percent return of the banking securities. Follow these steps to create the bar chart:

1. Select the close column and then call the unstack method.

close_prices = history['close'].unstack(level=0)

2. Call the pct_change method and then multiply by 100.

daily_returns = close_prices.pct_change() * 100

3. Call the mean method.

avg_daily_returns = daily_returns.mean()

4. Call the figure method with a figure size.

plt.figure(figsize=(15, 10))

5. Call the bar method with the x-axis and y-axis values.

plt.bar(avg_daily_returns.index, avg_daily_returns)

6. In the same cell that you called the bar method, call the title, xlabel, and ylabel methods with a title and the axis labels.

plt.title('Banking Stocks Average Daily % Returns')
plt.xlabel('Tickers')
plt.ylabel('%');

The Jupyter Notebook displays the bar chart.

You must import the plotting libraries and get some historical data to create heat maps.

In this example, you create a heat map that shows the correlation between the daily returns of the banking securities. Follow these steps to create the heat map:

1. Select the close column and then call the unstack method.

close_prices = history['close'].unstack(level=0)

2. Call the pct_change method.

daily_returns = close_prices.pct_change()

3. Call the corr method.

corr_matrix = daily_returns.corr()

4. Call the imshow method with the correlation matrix, a color map, and an interpolation method.

plt.imshow(corr_matrix, cmap='hot', interpolation='nearest')

5. In the same cell that you called the imshow method, call the title, xticks, and yticks, methods with a title and the axis tick labels.

plt.title('Banking Stocks and Bank Sector ETF Correlation Heat Map')
plt.xticks(np.arange(len(tickers)), labels=tickers)
plt.yticks(np.arange(len(tickers)), labels=tickers)

6. In the same cell that you called the imshow method, call the colorbar method.

plt.colorbar();

The Jupyter Notebook displays the heat map.

You must import the plotting libraries and get some historical data to create pie charts.

In this example, you create a pie chart that shows the weights of the banking securities in a portfolio if you allocate to them based on their inverse volatility. Follow these steps to create the pie chart:

1. Select the close column and then call the unstack method.

close_prices = history['close'].unstack(level=0)

2. Call the pct_change method.

daily_returns = close_prices.pct_change()

3. Call the var method and then take the inverse.

inverse_variance = 1 / daily_returns.var()

4. Call the pie method with the inverse_variance Series, the plot labels, and a display format.

plt.pie(inverse_variance, labels=inverse_variance.index, autopct='%1.1f%%')

5. In the cell that you called the pie method, call the title method with a title.

plt.title('Banking Stocks and Bank Sector ETF Allocation');

The Jupyter Notebook displays the pie chart.

You must import the plotting libraries and get some historical data to create 3D charts.

In this example, you create a 3D chart that shows the price of an asset on each dimension, i.e. the price correlation of 3 different symbols. Follow these steps to create the 3D chart:

1. Select the asset to plot on each dimension.

x, y, z = symbols[:3]

2. Select the close price series of each symbol.

x_hist = history.loc[x].close
y_hist = history.loc[y].close
z_hist = history.loc[z].close

3. Construct the basic 3D plot layout.

fig = plt.figure(figsize=(8, 8))
ax = fig.add_subplot(projection='3d')

4. Call the ax.scatter method with the 3 price series to plot the graph.

ax.scatter(x_hist, y_hist, z_hist)

5. Update the x, y, and z axis labels.

ax.set_xlabel(f"{x} Price")
ax.set_ylabel(f"{y} Price")
ax.set_zlabel(f"{z} Price")

6. Display the 3D chart. Note that you need to zoom the chart to avoid z-axis cut off.

ax.set_box_aspect(None, zoom=0.85)
plt.show()

The Jupyter Notebook displays the pie chart.