Mean reversion to a moving average

The code

Besides the usual totals, this script records two things that matter for this technique in particular: how many days were spent in a trade, and how far under water an open trade went before it closed.

Data the script reads: invented-prices.csv. Invented values, never a real market. Save it in one folder and run the script from that folder.

The file that was run: mean_reversion.py

# Mean reversion to a moving average: act when price is stretched away from its average.
# Prices come from invented-prices.csv: a random walk made by a script, never a real market.
# The result therefore says nothing about any real market. Read it for the method.
import csv

closes = []
with open("invented-prices.csv", newline="") as f:
    for row in csv.DictReader(f):
        closes.append(float(row["close"]))


def average(values):
    return sum(values) / len(values)


# Example values, picked only because they are easy to follow. They are not a suggestion.
DAYS = 20            # length of the average
STRETCH = 3.0        # how far below the average, in percent, counts as stretched
COST = 0.10          # points paid on every completed trade, a stand in for the spread

holding = False
entry = 0.0
results = []
days_held = 0
worst_while_open = 0.0   # the deepest any open trade went under water, in points

for day in range(DAYS + 1, len(closes)):
    yesterday = day - 1
    # The average ends at yesterday. Today's close is not in it.
    mean = average(closes[yesterday - DAYS + 1:yesterday + 1])
    gap = (closes[yesterday] - mean) / mean * 100
    price = closes[day]

    if holding:
        days_held += 1
        worst_while_open = min(worst_while_open, price - entry)

    if not holding and gap < -STRETCH:
        holding, entry = True, price          # stretched below the average: get in
    elif holding and gap >= 0:
        results.append(price - entry - COST)  # back at the average: get out
        holding = False

if holding:
    results.append(closes[-1] - entry - COST)

wins = [r for r in results if r > 0]
print("Trades:", len(results))
print("Trades that ended above zero:", len(wins))
if results:
    print("Smallest and largest trade:", round(min(results), 2), "and", round(max(results), 2))
print("Days spent in a trade:", days_held, "of", len(closes) - DAYS - 1)
print("Deepest an open trade went under water:", round(worst_while_open, 2))
print("Total points after costs:", round(sum(results), 2))
print("Simply holding over the same days:", round(closes[-1] - closes[DAYS + 1] - COST, 2))

What the run printed

Trades: 12
Trades that ended above zero: 5
Smallest and largest trade: -8.95 and 2.92
Days spent in a trade: 208 of 729
Deepest an open trade went under water: -11.18
Total points after costs: -3.71
Simply holding over the same days: -10.82

Output of the run on 9 Oct 2026, copied as printed. Every input to this run was invented, so the result says nothing about any real market.

How to read it

Look at the smallest and largest trade before the total. The largest gain is a few points and the largest loss is about three times that. This is the signature of mean reversion: many small gains and an occasional large loss, because the rule has no exit other than price coming back.

The deepest an open trade went under water is larger still. A test that only reports closed trades hides this. Someone following the rule would have had to sit through it.

The total is below zero and happens to be above what holding did over the same days. That is because the rule was out of a falling series most of the time, not because stretched prices came back. In a random walk they do not. It says nothing about any real market.