Python Tutorial (47) - Quantization

Time： 2024-09-19 Column：Python views：285

Python quantitative trading refers to the process of using the Python programming language, along with its libraries and tools, to analyze financial market data, develop trading strategies, and execute trades.

Python has become one of the most preferred programming languages for quantitative trading due to its simplicity, ease of learning, robust ecosystem, and rich financial libraries.

Quantitative trading is widely used in the financial sector. It allows traders to develop and execute trading strategies systematically, increasing trading efficiency and improving the science behind decision-making.

Quantitative trading mainly involves using mathematical and statistical methods, combined with computer technology, to analyze financial markets and develop trading strategies.

For more details on Python quantitative trading, you can refer to: Python Quantitative Trading.

Example Application

Let's look at a simple example of Python quantitative trading using a moving average strategy and Yahoo Finance data.

The basic idea of this strategy is to generate buy and sell signals by comparing the short-term and long-term moving averages.

Before running this example, you need to install three packages:

pip install pandas yfinance matplotlib

Package Explanation:

Pandas: A powerful open-source data processing and analysis library designed for efficient data manipulation.
yfinance: A library used for obtaining financial data, supporting the retrieval of stock, index, and other financial market data from Yahoo Finance.
Matplotlib: A 2D plotting library used for creating static, dynamic, and interactive data visualizations.

Fetching Historical Stock Data

Use yfinance to get historical stock data. Below is a simple example:

import yfinance as yf

# Fetch stock data
symbol = "600519.SS"
start_date = "2022-01-01"
end_date = "2023-01-01"

data = yf.download(symbol, start=start_date, end=end_date)
print(data.head())

Output:

                  Open         High          Low        Close    Adj Close   Volume
Date                                                                               
2022-01-04  2055.00000  2068.949951  2014.000000  2051.229980  1973.508057  3384262
2022-01-05  2045.00000  2065.000000  2018.000000  2024.000000  1947.309937  2839551
2022-01-06  2022.01001  2036.000000  1938.510010  1982.219971  1907.112915  5179475
2022-01-07  1975.00000  1988.880005  1939.319946  1942.000000  1868.416870  2981669
2022-01-10  1928.01001  1977.000000  1917.550049  1966.000000  1891.507446  2962670

Simple Data Analysis and Visualization

Using pandas for data analysis and matplotlib for visualization:

import yfinance as yf
import pandas as pd
import matplotlib.pyplot as plt

# Fetch stock data
symbol = "600519.SS"
start_date = "2022-01-01"
end_date = "2023-01-01"

data = yf.download(symbol, start=start_date, end=end_date)
# Simple data analysis
print(data.describe())

# Plot the stock price chart
data['Close'].plot(figsize=(10, 6), label=symbol)
plt.title(f"{symbol} Stock Price")
plt.xlabel("Date")
plt.ylabel("Price")
plt.legend()
plt.show()

The chart will look like this:

Python Tutorial (47) - Quantization

Backtesting Moving Average Crossover Strategy

Backtesting is the process of simulating and evaluating a trading strategy on historical market data.

Here is a simple example of backtesting a moving average crossover strategy. The strategy buys when the 50-day moving average crosses above the 200-day moving average, and sells when it crosses below. The strategy's performance is outputted as total return, annualized return, and maximum drawdown.

import yfinance as yf
import pandas as pd
import matplotlib.pyplot as plt

# Fetch stock data
symbol = "600519.SS"
start_date = "2021-01-01"
end_date = "2023-01-01"

data = yf.download(symbol, start=start_date, end=end_date)

# Calculate moving averages
data['SMA_50'] = data['Close'].rolling(window=50).mean()
data['SMA_200'] = data['Close'].rolling(window=200).mean()

# Initialize signal column
data['Signal'] = 0

# Generate crossover signals
data.loc[data['SMA_50'] > data['SMA_200'], 'Signal'] = 1
data.loc[data['SMA_50'] < data['SMA_200'], 'Signal'] = -1

# Calculate daily returns
data['Daily_Return'] = data['Close'].pct_change()

# Calculate strategy returns (shift(1) to avoid look-ahead bias)
data['Strategy_Return'] = data['Signal'].shift(1) * data['Daily_Return']

# Calculate cumulative returns
data['Cumulative_Return'] = (1 + data['Strategy_Return']).cumprod()

# Output strategy performance
strategy_performance = {
    'Total Return': data['Cumulative_Return'].iloc[-1] - 1,
    'Annualized Return': (data['Cumulative_Return'].iloc[-1] ** (252 / len(data))) - 1,
    'Max Drawdown': (data['Cumulative_Return'] / data['Cumulative_Return'].cummax() - 1).min(),
}

print("Strategy Performance:")
for key, value in strategy_performance.items():
    print(f"{key}: {value:.4f}")

# Plot cumulative returns
plt.figure(figsize=(10, 6))
plt.plot(data['Cumulative_Return'], label='Strategy Cumulative Return', color='b')
plt.plot(data['Close'] / data['Close'].iloc[0], label='Stock Cumulative Return', color='g')
plt.title("Cumulative Return of Strategy vs. Stock")
plt.xlabel("Date")
plt.ylabel("Cumulative Return")
plt.legend()
plt.show()

This will generate a chart similar to the one shown here:

Python Tutorial (47) - Quantization