Automated Trading Development in Python, Modifying Matplotlib to Plot Closing Prices and Volumes at Once

In recent years, automated trading systems have become quite popular among investors and traders in the financial markets. In particular, Python is a highly suitable language for building automated trading systems due to its various data analysis tools and libraries. In this article, we will detail how to develop an automated trading system using Python and visualize closing prices and trading volumes simultaneously using matplotlib.

1. Overview of Automated Trading Systems

An automated trading system is a program that executes trades automatically based on predefined rules. Such systems can operate on various financial products such as stocks, foreign exchange, and cryptocurrencies, using various techniques including machine learning, algorithmic analysis, and statistical methods to make trading decisions.

2. Installing Required Libraries

To develop automated trading with Python, we will use the following libraries. First, install the required libraries using the command below.

pip install numpy pandas matplotlib yfinance

3. Data Collection

Data for automated trading is very important. We will use the yfinance library to obtain closing price and trading volume data from Yahoo Finance. The data can be collected using the code below.

import yfinance as yf

# Data Collection
def get_stock_data(ticker, start_date, end_date):
    data = yf.download(ticker, start=start_date, end=end_date)
    return data

ticker = 'AAPL'  # Apple stock ticker
start_date = '2023-01-01'
end_date = '2023-12-31'
data = get_stock_data(ticker, start_date, end_date)
print(data.head())

3.1. Understanding the Data

In the code above, the get_stock_data function takes the specified stock ticker along with the start and end dates as arguments to load the data. The returned data includes the following information:

  • Open: Opening price
  • High: Highest price
  • Low: Lowest price
  • Close: Closing price
  • Volume: Trading volume

4. Data Visualization: Closing Prices and Trading Volume

Now we will visualize the collected data and plot the closing prices and trading volumes at the same time. We will generate the graphs using the matplotlib library.

4.1. Plotting the Closing Prices and Trading Volume

import matplotlib.pyplot as plt

def plot_price_volume(data):
    fig, ax1 = plt.subplots(figsize=(12, 6))

    # Plotting Closing Prices
    ax1.plot(data.index, data['Close'], color='blue', label='Closing Price')
    ax1.set_xlabel('Date')
    ax1.set_ylabel('Closing Price', color='blue')
    ax1.tick_params(axis='y', labelcolor='blue')
    ax1.legend(loc='upper left')

    # Second axis for adding Volume
    ax2 = ax1.twinx()  
    ax2.bar(data.index, data['Volume'], color='gray', alpha=0.3, label='Volume')
    ax2.set_ylabel('Volume', color='gray')
    ax2.tick_params(axis='y', labelcolor='gray')
    ax2.legend(loc='upper right')

    plt.title('Visualization of Closing Prices and Volume')
    plt.show()

# Data Visualization
plot_price_volume(data)

4.2. Code Explanation

The above plot_price_volume function visualizes the closing prices and volumes through the following steps:

  1. Plotting the Stock Closing Price: The closing price of the stock is plotted using ax1.plot as a blue line.
  2. Setting Axis Labels and Legend: Axes labels are set for both x and y axes, and legends are added to clarify the contents of each graph.
  3. Plotting Volume: Volume is added to the same graph as gray bars using ax2.twinx().
  4. Adding Graph Title: The title for the entire graph is set to make the visualization clear.

5. Automated Trading Simulation

After visualizing the data, we will now conduct a simple automated trading simulation. The basic strategy will utilize a moving average (MA) based strategy to generate trading signals and determine buy and sell points.

5.1. Adding Simple Moving Average (SMA)

def calculate_sma(data, window):
    return data['Close'].rolling(window=window).mean()

# Adding Simple Moving Average for Closing Price
data['SMA_20'] = calculate_sma(data, 20)
data['SMA_50'] = calculate_sma(data, 50)
print(data[['Close', 'SMA_20', 'SMA_50']].tail())

The above calculate_sma function calculates the simple moving average given the data and the moving average period (window). The 20-day and 50-day moving averages are calculated and added to the data frame.

5.2. Generating Trading Signals

def generate_signals(data):
    signals = []
    position = 0  # Current holding position (1: Buy, -1: Sell, 0: None)

    for i in range(len(data)):
        if data['SMA_20'][i] > data['SMA_50'][i] and position != 1:
            signals.append(1)  # Buy signal
            position = 1
        elif data['SMA_20'][i] < data['SMA_50'][i] and position != -1:
            signals.append(-1)  # Sell signal
            position = -1
        else:
            signals.append(0)  # No signal

    return signals

data['Signals'] = generate_signals(data)
print(data[['Close', 'SMA_20', 'SMA_50', 'Signals']].tail())

The generate_signals function generates trading signals based on the simple moving average. When SMA 20 crosses above SMA 50, a buy signal is generated, and conversely, when crossing below, a sell signal is generated.

6. Performance Analysis

Now that trading signals have been generated, we will analyze the performance. The portfolio's performance can be evaluated based on the buy and sell signals.

6.1. Calculating Returns

def calculate_returns(data):
    data['Market_Returns'] = data['Close'].pct_change()
    data['Strategy_Returns'] = data['Market_Returns'] * data['Signals'].shift(1)  # Returns based on trading signals
    data['Cumulative_Market_Returns'] = (1 + data['Market_Returns']).cumprod() - 1
    data['Cumulative_Strategy_Returns'] = (1 + data['Strategy_Returns']).cumprod() - 1

calculate_returns(data)
print(data[['Cumulative_Market_Returns', 'Cumulative_Strategy_Returns']].tail())

Here, the calculate_returns function calculates the returns, comparing market returns with strategy returns. Cumulative returns are calculated to easily analyze performance.

7. Comparing Performance through Graphs

Finally, we can visualize cumulative returns to compare the performance of the strategy. Let’s visualize using matplotlib.

def plot_performance(data):
    plt.figure(figsize=(14, 7))
    plt.plot(data.index, data['Cumulative_Market_Returns'], label='Market Returns', color='orange')
    plt.plot(data.index, data['Cumulative_Strategy_Returns'], label='Strategy Returns', color='green')
    plt.title('Market Returns vs Strategy Returns')
    plt.xlabel('Date')
    plt.ylabel('Cumulative Returns')
    plt.legend()
    plt.show()

plot_performance(data)

8. Conclusion

In this article, we examined how to visualize closing prices and trading volumes along with a simple automated trading system using Python. Additionally, we understood the basic concepts of automated trading through generating trading signals based on moving averages and performance analysis. Going forward, explore developing more complex strategies and applying various techniques to build a more effective automated trading system.

Based on proposed methods, you can also proceed to advanced modeling tasks utilizing machine learning, deep learning, etc. Furthermore, try developing more advanced trading strategies by applying various indicators and strategies.

Finally, as you practice the code and concepts, enjoy the process of building your own automated trading system!