Python Automated Trading Development, Drawing Matplotlib Bar Charts

Python has established itself as one of the powerful tools in the world of data science and automation.
Building automated trading systems in the financial markets has become an attractive challenge for many traders.
In this article, we will detail how to draw Bar charts using Matplotlib, which is an important element in visualizing data in automated trading systems.

1. What is Matplotlib?

Matplotlib is a Python library for data visualization that provides the functionality to create various types of charts.
In particular, Bar charts are useful for visually comparing data and play a significant role in analyzing financial data.

1.1 Installing Matplotlib

Matplotlib can be easily installed using pip.
Run the command below to install Matplotlib. 

pip install matplotlib

2. Overview of Bar Charts

A Bar chart is a graph that represents the values of each category as the height of rectangles.
It has the advantage of allowing for simple yet powerful comparisons of data.
For example, displaying the monthly returns of a specific stock in a Bar chart allows you to quickly see the performance for each month.

3. Practical Exercise on Visualizing Automated Trading Data Using Bar Charts

Now, let’s draw a Bar chart through a real example.
We will use hypothetical stock data to visualize trading performance.
First, let’s import the necessary libraries and generate the data.

3.1 Generating Data


import matplotlib.pyplot as plt
import numpy as np

# Generate hypothetical data
categories = ['January', 'February', 'March', 'April', 'May']
profits = [100, 200, -150, 300, 250]

# Drawing the Bar chart
def plot_bar_chart(categories, profits):
    plt.bar(categories, profits, color='blue')
    plt.title('Monthly Returns')
    plt.xlabel('Month')
    plt.ylabel('Returns')
    plt.grid(axis='y')
    plt.axhline(0, color='black', lw=1)
    plt.show()

# Call the chart drawing function
plot_bar_chart(categories, profits)

3.2 Code Explanation

The above code shows the process of creating a simple Bar chart.
Here, the `plot_bar_chart` function is responsible for drawing the Bar chart based on the provided categories and return data.

  • Creating Bar chart: The chart is created using the `plt.bar()` function.
  • Setting Title and Labels: The chart title and axis labels are set using `plt.title()`, `plt.xlabel()`, and `plt.ylabel()`.
  • Adding Grid: The Y-axis grid lines are added using `plt.grid(axis=’y’)`.
  • Adding Baseline: A baseline is added at Y-axis 0 using `plt.axhline(0, color=’black’, lw=1)`.

4. Using Real Data

Although we used hypothetical data in our exercise, we can create more meaningful charts using actual financial data.
APIs such as Yahoo Finance API or Alpha Vantage API can be used to provide financial data.
In this example, we will use the pandas and yfinance libraries to fetch real stock data and draw a Bar chart.

4.1 Importing Data with yfinance


import yfinance as yf
import pandas as pd

# Download stock data
ticker = 'AAPL'
data = yf.download(ticker, period='1y', interval='1mo')
data['Monthly Change'] = data['Close'].diff()
data = data[data['Monthly Change'].notnull()]

# Processing data
months = data.index.strftime('%Y-%m').tolist()
profits = data['Monthly Change'].tolist()

# Drawing a Bar chart with real data
plot_bar_chart(months, profits)

4.2 Code Explanation

The above code demonstrates how to download monthly stock price data for Apple Inc. (AAPL) over the past year using the yfinance library, calculate returns, and draw a Bar chart.

  • Downloading Data: Specific stock data is downloaded using `yf.download()`.
  • Calculating Returns: The monthly returns are calculated by calling `data[‘Close’].diff()`.
  • Drawing Bar Chart: Finally, the Bar chart is drawn using the `plot_bar_chart()` function.

5. Customizing Bar Charts

Matplotlib offers various customization options to make charts more beautiful and useful.
Below are a few ways to customize Bar charts.

5.1 Changing Colors and Applying Styles


def plot_custom_bar_chart(categories, profits):
    plt.bar(categories, profits, color='skyblue', edgecolor='darkblue')
    plt.title('Monthly Returns', fontsize=16)
    plt.xlabel('Months', fontsize=12)
    plt.ylabel('Returns (Currency)', fontsize=12)
    plt.xticks(rotation=45)
    plt.grid(axis='y', linestyle='--')
    plt.axhline(0, color='red', lw=1)
    plt.tight_layout()
    plt.show()

plot_custom_bar_chart(months, profits)

5.2 Code Explanation

The `plot_custom_bar_chart` function adjusts the color, font size, and axis label rotation of the Bar chart to make it more visually appealing.

  • Color and Border: The color and border color of the bars are specified using `color` and `edgecolor`.
  • Title and Label Font Size: The font size of the chart title and labels is adjusted using `fontsize`.
  • Axis Label Rotation: The X-axis labels are rotated 45 degrees using `plt.xticks(rotation=45)` to improve readability.
  • Line Style Changes: The style of the grid lines is changed using `plt.grid(axis=’y’, linestyle=’–‘)`.

6. Conclusion

Using Matplotlib to draw Bar charts is very useful for achieving effective data visualization in automated trading systems.
Through this tutorial, we learned not only the basics of generating Bar charts but also how to create realistic charts with actual data,
and how to perform custom visualizations through various styling options.
These skills will greatly help in visually analyzing and improving trading strategies.

6.1 Additional Learning Resources

References

– Python for Data Analysis, Wes McKinney
– Python Data Science Handbook, Jake VanderPlas