# How to calculate an EMA Golden Cross with Python 3, MetaTrader 5, and Pandas

#### Automated Trading Bot with MetaTrader5 and Python

There are a ton of signals to analyze when using quantitative analysis for stock/crypto/futures/FOREX trading!

### About This Series

This series demonstrates the automated analysis of 8 different market signals.

Using Python 3, Python Pandas, and MetaTrader5, I’ll show you how to calculate 8 common signals.

All code for this tutorial can be found on my GitHub, and I’ve included working code samples throughout (use at your own risk, give me a shout-out if you do).

#### What You Need

Requirements and assumed knowledge as follows:

- Already connected to MetaTrader 5. This article shows you how, I’m using the variant from IC Markets.
- Windows 10 or above. For reasons known only to MetaTrader, the Python API only works on Windows 😊
- Python 3. This series was built with Python 3.10

### The Golden Cross

#### Introduction to the Golden Cross Pattern

In quantitative analysis, the Golden Cross pattern is often used to identify bullish breakouts for a price level. It identifies a moment when a short-term moving average crosses **above** a longer-term moving average, as shown in the example chart below:

Theoretically, this calculation can be applied to any time-period, however, it is common to use the 15-Day moving average and 50-Day moving average.

#### How to Calculate

Mathematically, a Golden Cross occurs when the previous short-term moving average is below the previous long-term moving average, followed by the current short-term average moving above the current long-term moving average.

Simplified into pseudo-code:

- Determine the previous 15-day moving average
`prev_15`

- Determine the previous 50-day moving average
`prev_50`

- Determine the current 15-day moving average
`curr_15`

- Determine the current 50-day moving average
`curr_50`

**If**`prev_15 < prev_50`

**AND**`curr_15 > curr_50`

:`golden_cross = True`

This can be calculated using the Simple Moving Average (SMA) and Exponential Moving Average (EMA).

### How to Code

#### Before demonstrating the code to calculate an EMA Death Cross, I’ll outline a couple of considerations:

**Precision.**Because the EMA is a weighted average, any imprecision in the price will continue to replicate, effectively forever. The only way to eliminate any imprecision would be to calculate the EMA using every available data point for a given timeframe.**Compute Time.**Depending on your system, the compute time required to calculate an EMA can be huge. For example, in my testing, I calculated a single EMA across 50,000 1-minute candles, taking approximately 15 minutes. Clearly, that is unworkable. There are techniques such as multiprocessing to speed this up, however, I’ve chosen to limit the calculation for this series.

As a result, you’ll need to figure out what level of precision you’re comfortable with. I’ve chosen to use a candle limit of 1000 rows for this series, on my system this completes in < 1 second.

#### Generic Death Cross Function

Let’s start with a generic EMA function that returns an intact Pandas Dataframe. Here’s the code:

```
# Define function to calculate an arbitrary EMA and return Dataframe
def calc_generic_ema_with_dataframe(symbol, timeframe, ema_size, num_rows):
raw_data = mt5_interface.query_historic_data(symbol=symbol, timeframe=timeframe, number_of_candles=num_rows)
# Convert into Dataframe
dataframe = pandas.DataFrame(raw_data)
# Create column string
ema_name = "ema_" + str(ema_size)
# Create the multiplier
multiplier = 2/(ema_size + 1)
# Calculate the initial value (SMA)
# pandas.set_option('display.max_columns', None) # <- use this to show all columns
# pandas.set_option('display.max_rows', None) # <- use this to show all the rows
initial_mean = dataframe['close'].head(ema_size).mean()
# Iterate through Dataframe
for i in range(len(dataframe)):
if i == ema_size:
dataframe.loc[i, ema_name] = initial_mean
elif i > ema_size:
ema_value = dataframe.loc[i, 'close'] * multiplier + dataframe.loc[i-1, ema_close]*(1-multiplier)
dataframe.loc[i, ema_name] = ema_value
else:
dataframe.loc[i, ema_name] = 0.00
# print(dataframe) # <- use this to print the dataframe if you want to inspect
return dataframe
```

The previous function returns a list of all EMA’s for the last 1000 candles (required for a weighted moving average). Therefore, to determine if a Cross of Death event has occurred, extract the `close`

values for the last 2 candles to compare:

```
import generic_ema
import pandas
# Function to calculate a generic Golden Cross
def generic_ema_golden_cross(symbol, timeframe):
# Retrieve the 15 candle EMA
ema_15 = generic_ema.calc_generic_ema_with_dataframe(symbol=symbol, timeframe=timeframe, ema_size=15, num_rows=1000)
# Retrieve the 50 candle EMA
ema_50 = generic_ema.calc_generic_ema_with_dataframe(symbol=symbol, timeframe=timeframe, ema_size=50, num_rows=1000)
# Extract the previous values. Number_of_rows - 2 for both EMA 15 and EMA 50
prev_15 = ema_15.loc[998, 'close']
prev_50 = ema_50.loc[998, 'close']
# Extract the current values. Number_of_rows - 1 for EMA 15 and EMA 50
curr_15 = ema_15.loc[999, 'close']
curr_50 = ema_50.loc[999, 'close']
# Compare
if prev_15 < prev_50 and curr_15 > curr_50:
return True
return False
```

#### EMA Golden Cross Function

Finally, integrate the EMA Golden Cross calculation using the timeframe D1:

```
# Calculate a 'classic' Golden Cross event
def ema_golden_cross(symbol):
return generic_ema_golden_cross(symbol=symbol, timeframe="D1")
```

### Wrapping Up

That’s all folks. That’s how you can integrate the calculation of an EMA Golden Cross into your Python Trading Bot. I’d love to hear how you’re using it, so drop me a line in the comments!

### Say Hi!

I love hearing from my readers, so feel free to reach out. It means a ton to me when you clap for my articles or drop a friendly comment — it helps me know that my content is helping.

❤