Here’s a quick update on what’s been happening behind the scenes and where this newsletter is heading.

For the past five months, I’ve been reading and working on valuation models for football transfers. What was initially planned as a simple newsletter edition has grown into something much deeper than expected.

Going forward, the newsletter will move away from the “teaching Python” format and toward market-focused analysis. Think Swiss Ramble, but for player valuations, salaries, and performance. This includes:

• Player transfer and wage evaluations (obviously)

• Assessing how well teams perform in the transfer market—and how players perform at the negotiation table

• Transfer window reviews

• Case studies (e.g. what Kevin De Bruyne’s data scientists might have said to Man City during negotiations for his €80 million contract extension in 2021)

The previous articles won’t disappear—only the name of the newsletter and my handle will change.

So the Python Football Review is evolving into the Football Market Review (hopefully I won’t change the name again before the first new post is out).

If this isn’t something you’re interested in, please feel free to unsubscribe.

If it is, I’m glad to have you here.

Also—if there’s something within these topics you’d like to learn more about or read regularly, drop your ideas in the comments or just hit reply. I’d genuinely love your feedback.

Cheers,
Martin

FiveThirtyEight has always had a kind of mythic status in the football world. Their Soccer Power Index (SPI) was one of the first “super-model” rating systems I stumbled upon when I began my own analytics journey. And for years — before it was shut down — SPI became a reference point for pre-game probabilities and end-of-season title chances across football Twitter.

Last week, I came across a historical dataset that included SPI’s match-by-match outcome probabilities. Naturally, the first question that came to my mind was:

“If someone blindly trusted SPI for years… would they have made money?”

And that curiosity brings us to today’s issue.

Welcome to The Python Football Review #019.

In this edition, we’ll explore how much one would have won (or lost) over seven seasons by betting strictly according to SPI’s implied probabilities — and we’ll compare those numbers to the sharpest odds in world football: Pinnacle’s closing line.

As always, the Python notebook is included at the end so you can replicate everything yourself from scratch (and mock my results).

Let’s get into it.

A Few Words About the Data

The historical SPI dataset — available on Kaggle — includes 40 leagues (male and female, national and international) covering the 2016/17 to 2022/23 seasons. For every match, we have SPI’s estimated probability of home win, draw and away win as illustrated below.

From these probabilities we’ll compute fair odds simply by taking the inverse. For example, SPI gave Bastia a 4.63% chance of beating PSG in the opening match of 2016/17. The corresponding odds according to FiveThirtyEight are therefore 1 / 0.0463 = 21.6 which means that if you bet 1€ on that outcome, you would have won a total of 21.6€ back (in case if a winning wager of course).

To analyse profitability, I then needed the market odds for each match. Based on ease of downloading, I downloaded the market odds for 18 of those 40 leagues (my newsletter, my rules), which is still a very healthy sample.

The odds data comes from Joseph Buchdahl’s football-data.co.uk, as usual. For market prices, we take Pinnacle closing odds, because: If your system consistently beats Pinnacle’s closing price, you almost certainly have an edge.

After matching team names across the two datasets, we end up with 36,335 matches. And here is what the final analysis table looks like:

• fair_home, fair_draw, fair_away → from SPI

• home_odds, draw_odds, away_odds → Pinnacle closing odds

Here’s the overall coverage.

The Betting Simulation

For each match, we look for value. A value bet exists when Market odds > Fair odds.

Simple example: In Bastia vs PSG, SPI assigns PSG fair odds of 1.19, while Pinnacle offers 1.34. That’s a 12.6% value edge ((1.34/1.19) -1), which means — in theory — we’d place a bet on PSG. To avoid over-exposure, we place only one bet per match, even if multiple outcomes show theoretical value. For each bet we will place a single unit wager.

So to recap: we’re about to test 36,335 matches across 7 seasons and 18 leagues. We’ll compare SPI’s fair odds to Pinnacle’s closing odds and look for value. Whenever value appears, we place a single 1-unit bet on the outcome with the highest positive edge.

And the question is: What would the profitability look like? Would SPI beat the market? Or would it behave like a very polite random walk?

Let’s find out.

Simulation Results

Over the full period, the model would have generated 33,929 bets, each taken when the SPI-implied probability appeared higher than Pinnacle’s market probability.
Across these bets, the average perceived value was around +18.2% (that’s a lot), and the system achieved a 31% win rate.

However, despite the perceived positive expected value, the long-term outcome was a net loss of about 2,114 points, corresponding to a –6.2% rate of return. In practical terms:

For every €100 placed, you’d expect to lose about €6.

Can the results be improved? Of course. There are dozens of data mining filtering techniques we could explore, such as:

• restricting to lower odds (more likely events)

• betting only when value exceeds certain thresholds — or avoiding extreme value outliers (model/market mistakes)

• focusing on home-only strategies (or excluding draws)

• applying Kelly-criterion staking

These could change the curve and potentially improve performance.

But the general conclusion is :

A naïve, blind strategy that follows SPI as a pricing model would lose money against Pinnacle.

Is this surprising? Not really.

No one ever claimed SPI was designed for betting. And importantly, we used Pinnacle closing odds, widely considered the sharpest lines in the world.

And SPI—at its core—is:

• a static pre-game index

• ignoring late team news & therefore blind to injuries, squad rotation, fatigue, travel, and line-up announcements

• accessible to everyone well in advance.

Meanwhile, Pinnacle’s closing line:

• reflects the aggregated knowledge of the sharpest bettors

• adjusts dynamically until the final seconds before kickoff

• incorporates global betting pressure

• reacts instantly to breaking news

So would it be surprising if a static, pre-game, publicly available rating system consistently beat the closing line of the sharpest bookmaker in the world?

No — exatly the opposite would be suprising.

Having said that, here’s how SPI’s predicted probabilities fared against the actual results. In the chart below, we compare SPI’s probabilities to those implied by Pinnacle’s closing odds, and we check how well each aligns with reality.

A perfectly calibrated model would sit right on the dashed 45° line — meaning that events predicted at 30% really happen 30% of the time, 60% events happen 60% of the time, and so on.

Pinnacle (blue) is (for the most part) almost glued to that line. This is exactly what you’d expect from the sharpest bookmaker in the world. Their odds, once binned at 2.5% intervals, map extremely closely to actual match outcomes. When Pinnacle says something is 70% likely, it really is about 70% likely.

SPI (orange), however, shows consistent patterns of miscalibration:

• At low probabilities, SPI underestimates the probabilities— for example events it predicted at 5% happened around 9% of the time.

• Across most of the range (10–90%), SPI systematically overestimates true frequencies — for example, matches it rated at 50% actually occurred only 41% of the time.

• At high probabilities (90–100%), SPI becomes too conservative again, assigning lower win chances than what actually happened on the pitch.

In simple terms: SPI gets the direction right, but the confidence wrong.

It knows which team is stronger, but it consistently misjudges by how much. And this miscalibration is exactly why betting strictly on SPI’s probabilities — without adjustments — fails to beat Pinnacle. Pinnacle isn’t just predicting winners; it’s capturing the true likelihood with remarkable precision.

A broader reminder

This little experiment highlights an important point: even well-constructed “super-computer” models have limits. FiveThirtyEight’s SPI was analytically strong, but that doesn’t automatically translate into beating the sharpest sports betting markets on a match-by-match basis — and it was never designed to.

End-of-season simulations, title probabilities, and playoff chances were always where SPI shined. These tools are incredibly valuable for understanding long-term dynamics, but they are still just simulations. They don’t replace real-time information, market pressure, or closing-line pricing.

And to be clear: SPI was useful — very much so.
It consistently captured directional team strength, meaning it generally understood who the stronger and weaker sides were based on recent performance. It was also transparent in how it was built (combining xG and non-shot xG), which allowed you to adjust ratings yourself. If you felt a team was over- or under-performing those metrics you could mentally nudge the probabilities up or down.

So no, SPI couldn’t beat Pinnacle’s game-by-game closing odds. But that’s an unrealistic benchmark for any static pre-game public model.

What SPI did provide was a solid, interpretable foundation — a starting point for reasoning about team quality, season trajectories, and long-term probabilities. And for most fans, analysts, and hobbyist forecasters, that is already incredibly powerful.

Boom — that was FiveThirtyEight vs Pinncle.

This was a fun exercise, even if I’m a little disappointed the curve ends well below zero. I honestly expected something slightly closer to breakeven.

But maybe that’s the next step — building a more refined, bottom-up forecasting model that incorporates last-minute news and seeing whether that can close the gap.

If you want to reproduce the results yourself, the code is available below.

Download Python Code

Thanks for reading all the way to the end.

See you next week,
Martin

Welcome to The Python Football Review #018.

In this issue, you’ll learn:

• how much the average shot distance has dropped over the last 11 seasons

• whether this shift actually affected conversion rates

• and whether the “death of the screamer” is a myth or a real trend

As always, the full code is available at the end so you can reproduce the analysis from scratch, check the numbers, and mock my conclusions if you want.

Let’s get into it.

A few words on the data

For this study, we’ll use 11 seasons of data (2014/15 to 2024/25) from Europe’s top five leagues, courtesy of Understat (via soccerdata). The dataset includes roughly half a million shots. We focus solely on open-play shots.

The data is already clean. We just need to add three features:

1. shot distance in meters, calculated from the pitch coordinates of each shot

2. a dummy variable (1/0) for shots outside the box

3. a dummy variable for shots taken from 25+ meters (our definition of a long-range shot)

1 — How did shot volume evolve?

Across Europe’s top five leagues, the average number of open-play shots per match has been remarkably stable. In 2014/15 we recorded 16.6 shots per match, and in 2024/25… also 16.6.

There’s some negligible year-to-year variance, but nothing that suggests a structural change. So no, teams are not shooting less overall.

What about the shots from outside the box? Now it gets interesting. Outside-the-box shots fell from 8.6 to 6.9 per match — a 20% decline.

And what about the shots from 25 meters or more (i.e. the “screamer zone”) ? These shots dropped from 5.4 to 3.7 per match — a 31% drop.

This is the trend people usually talk about when they say “xG killed long-range shots,” and to be fair, the decline is real and observable across all leagues.

2 — What about shot distance?

Across all open-play shots, the average shot distance dropped from 20.8m to 19.1m — an 8% decrease.

Outside-the-box shots distance dropped from 27m to around 26m — roughly 4% down.

As for true long-range efforts (25m+), the average distance basically stayed the same. Don’t be misled by the upward-sloping line in the chart — yes, it’s increasing, but the Y-axis range is only 1.6 meters. Technically, between 2014/15 and 2024/25, the average distance rose by just 0.8%, from 29.93m to 30.17m. In other words, not significant.

Taken together, this section paints a clear picture:

Teams take the same number of shots as before — but they take far fewer from long range.

Thank you, Captain Obvious. Now that we confirmed what everobody talked about, let’s get into the conversion rates.

3 — Conversion rates

Now comes the fun part: Has this shift actually hurt long-range scoring?

Across all open-play shots, conversion increased from 9.3% to 10.8% — a 1.5 percentage point increase. Should not come as a surprise since shots are being taken from closer positions.

Outside-the-box conversion rose from 3.3% to 4.6% — up 1.3 percentage points, which is meaningful at that low baseline.

As for the long-range shots, conversion increased from 1.7% to 2.8% — a 1.1 pp increase, the largest relative jump of all.

What appears to be happening is teams keeping the risky long shots out of the game.

Long-range shots are clearly on the decline. On average, you’ll only see 1.7 true long-range attempts per match today. But when teams do shoot from distance, the chances of observing a goal as a spectator are 65% higher than a decade ago.

Why? Because only the right players are allowed to try. The long-range “permission” has shifted from everyone to only the players who can actually hit them.

So did xG kill the long-range screamers?

Yes, the average shot distance dropped. Yes, the volume of long-range shots dropped — dramatically. But the idea that screamers are “dead” is… incomplete.

If you care about volume, then yes, long-range shooting is fading.

If you care about expected reward, then screamers are alive and well — in fact, they’re converting at the highest rates we’ve seen in more than a decade.

Modern footballers haven’t stopped shooting from range — they’ve simply stopped shooting bad long-range shots.

So the next time your Granit Xhaka (or your Declan Rice, or your Enzo Fernández) winds up from 25 yards… well, the numbers say it’s a better shot today than it was back in 2014.

And before I leave you, here’s the scatter plot of every player who attempted at least 30 shots across the dataset. Dotted lines are the medians.

There’s one dot sitting right above the 9% conversion from 31 meters. That’s Xabi Alonso — as if you needed reminding of how outrageous he was from range.

Boom — and that’s the story behind the supposed death of the long-range screamer.

If you’re interested in replicating all the figures from scratch, you can download the full code below.

Download the Python Code

As always, thank you for reading all the way to the end.

See you next week,

Martin

So I decided to put that to the test.

Welcome to The Python Football Review #017 — an edition where we compare xG from four of the most widely used sources in football analytics: Opta, StatsBomb, Wyscout and Understat.

By the end of it, you’ll learn:

• How closely the four providers agree on the same matches

• How quickly their xG trends converge as the season unfolds

• Which models consistently diverge

• And how different your league table would look depending on which xG provider you trust

Let’s dive in.

1 — The Data

For this edition, we’re working with five full seasons of matches (2017/18 to 2021/22) across the Premier League, Bundesliga, Serie A, La Liga and Ligue 1.

For every game, the dataset includes the full-time xG scoreline from four sources: Opta, StatsBomb, Wyscout and Understat. Here’s a quick look at the structure of the dataset:

Two quick disclaimers before we go further:

• For obvious reasons, I can’t share the full dataset — which also makes sharing the Python code somewhat pointless, since you wouldn’t be able to reproduce the tables without the underlying data. (So no Python template for this edition.)

• The four sources were extracted at different points in time: StatsBomb → May 2022, Wyscout → October 2022, Opta → May 2023, Understat → November 2025. I mention this because some providers occasionally retro-update past xG values (more on that in the end). If any discrepancies show up, timing could be part of the explanation.

How complete is the dataset?

Across the five leagues and five seasons, we’re very close to full coverage. A handful of matches are missing because at least one provider had no xG values for that game. The 2019/20 Ligue 1 season was interrupted due to Covid, hence the 279 games.

Overall, it’s a very healthy sample.

Basic descriptive statistics

Before diving deeper, let’s look at some classic descriptive stats — the mean, median, standard deviation and maximum xG values across all teams, all games and all providers.

A few quick observations:

• StatsBomb and Opta are similar across every summary metric.

• Understat runs slightly higher on average (mean team xG = 1.38) and just about the same median-wise (1.22).

• Wyscout is the most generous model in this sample — highest mean (1.44), highest variance and the highest maximum single-team xG per match.

But this is just basic summary stuff. Let’s now look at the full distributions.

2 — Comparing xG distributions across providers

How to read this figure

This is a smoothed distribution (a KDE curve) of all xG values assigned per team per match. It shows how often each xG level occurs across thousands of matches.

The x-axis is the xG a team had in a match (0 → 7). The y-axis is a relative frequency: higher peaks mean “this xG value happens more often.”

• Where the curves sit higher, that provider gives those xG values more frequently.

• Where the curves tail off more slowly, that provider gives more high-xG games.

The exact height doesn’t matter — it’s the shape and position of each curve relative to the others.

What we learn from it

• Opta and StatsBomb are nearly identical. Their curves overlap almost perfectly, which tells us the two models likely behave very similarly on a match-by-match basis.

• Understat runs a bit higher at the very low end (below ~0.4 xG) and again at the higher end (above ~2.3 xG), while sitting slightly lower in the middle. A subtle but noticeable difference.

• Wyscout assigns the lowest xG values up to around 1.5, and then consistently shifts furthest to the right with the heaviest tail. In other words, Wyscout hands out higher xG more often and produces the most extreme single-match xG values.

Match-level agreement between providers

To complement the distribution plots, here’s a simple correlation matrix comparing each provider’s match-level xG values. Each number is a Pearson correlation: 1.00 means identical behaviour, lower values mean more disagreement.

What this tells us:

• Opta × Understat show the strongest alignment at match level (0.96).

• Opta × StatsBomb and StatsBomb × Understat are also very tight (≈0.92–0.93).

• Wyscout is an outlier — its match-level xG correlates the least with everybody else (0.86–0.88 range).

Here are a few scatterplot (with linear fits on top) before we zoom out ask a bigger question: How quickly do these (small?) differences disappear once we look at season-long trends instead of single matches?

3 — How quickly do providers agree as the season unfolds?

So far, we’ve looked at individual xG values. But single matches only get you so far.

To really understand how similar the providers are, we need to zoom out and look at what happens as the season progresses. Instead of comparing isolated xG values, we compare each team’s cumulative xG difference — the running total of xG for minus xG against — and check how closely the providers track each other over time.

In other words: As teams pile up more matches, how quickly do the providers’ season-long xG trends start agreeing with one another?

That’s exactly what the chart below shows.

What you’re looking at

Each line shows (once more) the Pearson correlation (the one you first learned at school) between two providers’ cumulative xG differences at each match week. A value of 1.0 means the two providers generate identical season-long curves. A value of 0 means the curves have nothing in common. Put simply: the higher the line, the stronger the agreement.

What we learn from this

First, notice that all provider pairs start fairly high — even the least aligned pair begins around 0.87, which is already strong.

But some pairs converge faster and more tightly than others. Three clear clusters emerge:

1. Opta x Understat: the fastest and strongest agreement. After just a few matches, they’re already above 0.97, and by the end of the season they’re sitting at 0.99. These two tell virtually the same season-long story.

2. Opta x StatsBomb and StatsBomb x Understat: the middle cluster. By the 15-game mark, both pairs push past 0.98. Consistent, tight, and very stable.

3. Anything involving Wyscout: the outlier. Pairs with Wyscout start lower (0.88–0.90) and take longer to catch up. Even late in the season they peak slightly below the others. Wyscout “thinks differently,” but still gets close in the long run.

By season’s end, every pair reaches very strong agreement (>0.97). That tells us that while providers may disagree on individual matches, their season-long signals eventually converge — even for Wyscout.

4 — Biggest differences

Now that we understand how the providers move together, let’s look at something a bit more fun (and perhaps more intuitive): How often do providers disagree on who “won” the xG battle in a match?

For every game, we’ll assign a winner based on which team created more xG (according to each provider). That gives us three possible scenarios:

Scenario 1 — All four providers agree

Example: Tottenham vs Arsenal (20/21) — Even though Spurs won on the scoreboard, all four models agree Arsenal created the better chances. (Why this happens is a newsletter of its own…)

Scenario 2 — One provider disagrees

Example: Everton vs Brighton — Three models choose the same xG winner. The fourth — Wyscout in this case — goes the other way.

Scenario 3 — A 2-vs-2 split

Example: Liverpool vs Leeds — Opta + Understat (in this case) on one side, StatsBomb + Wyscout on the other.

How often does each scenario occur?

Across all five seasons and all five leagues, here’s the breakdown:

• 76.1% of games → all four providers agree

• 15.9% → exactly one provider disagrees

• 8.0% → a 2–2 split

I don’t know if this surprises you, but next time you’re unhappy with xGPhilosophy’s scoreline on X, remember this: in roughly 1 out of 4 games, you can turn to another provider and find a different xG storyline to defend your team’s dignity — or to complain that xG is “broken.”

(That was irony for the xG haters out there.)

Moving on…

Who is the lone dissenter?

When exactly one model goes its own way, it’s overwhelmingly Wyscout with 45% of all 1-dissenter games. StatsBomb follows with 23% and then come Understat and Opta with 16%. No shock here — at this point in the newsletter, Wyscout consistently emerges as the “free spirit” of the group.

Which pairs disagree together in 2-vs-2 splits?

When we get a split vote, here’s how it breaks down:

The way to read this table is simple: among all 2-vs-2 split games, 38.6% of the time it’s StatsBomb + Wyscout teaming up. In 21.5% of cases it’s Understat + Wyscout, and in 15.4% of cases it’s StatsBomb + Understat.

Once again, Wyscout is the model that most often breaks away from the others. (And I promise I’m not trying to make this newsletter about Wyscout — the numbers are doing it for me.)

5 — Who Ranks Teams the Most Differently?

Let’s now move from match-level disagreements to something even more practical: How much do the providers diverge when ranking teams over a full season?

For this section, we rank every team in every league-season based on their season-long xG difference (xG for – xG against) according to each provider. Then we look at the largest gaps between those rankings — the cases where the four models disagree the most about how good (or bad) a team really was.

Here are the 10 biggest “disagreements”:

The standout case is Bologna (2020/21). Wyscout ranked them 18th, Opta and Understat both had them 11th, and StatsBomb put them 14th — a spread of 7 places, the biggest in the entire dataset.

And as you’ll see across the top 10 cases, Wyscout tends to offer either the best or the worst ranking in these big-disagreement seasons.

Even if we ignore Wyscout for a moment, there are still interesting differences. For instance:

• Werder Bremen (2019/20) → StatsBomb had them 10th, Opta had them 15th

• Nîmes (2019/20) → StatsBomb would have relegated them (20th), while Opta had them at 16th, safely above the drop

Now, keep in mind these are the most extreme ranking spreads. I’m not sure what I expected, but given the earlier convergence results — showing that all four models eventually align over the long run (just at different speeds) — this shouldn’t really shock us. A range of 5–6 places feels… reasonable. (Does it shock you?)

That said, the key takeaway is this: If you really want to criticise xG, here’s your ammunition: depending on the provider you choose, a team can be “relegated” or “saved.”

(That’s another joke — but the numbers do make the point.)

6 — Which model gets you closest to reality?

So far we’ve compared the providers to each other. But the really important question is: does it matter which xG source you use when you compare it to actual results?

Surprisingly… much less than you’d think.

Actual Points vs Expected Points (xPoints)

The chart below shows how well each provider’s cumulative expected points (xPoints) tracks actual points won, week by week.

If you’re new to xPoints: it’s simply the probability of a team winning/drawing/losing based on its xG, typically modelled with a Poisson distribution (McKay Johns has a great beginner-friendly explanation of this here).

What the chart shows is that all four providers track reality in a similar way. One model does lag a bit behind the others (no need to name it — you already know).

Understat performs best, but the margin vs Opta/StatsBomb is small. Understat is also the first to cross 80% correlation with real points — around matchweek 10. StatsBomb follows at matchweek 14. Opta around matchweek 15. And our usual outlier joins later (matchweek 17).

This means that Understat’s xG model aligns with real results the fastest, despite being the only source here that isn’t a traditional data provider. Funny how this works.

Goal Difference vs xG Difference

This second chart compares actual goal difference with xG difference.

Here the story is similar — but the gaps widen slightly: Understat again leads the pack. Opta and StatsBomb stay close together. Wyscout drifts below the others more noticeably. No model collapses completely, but some definitely require more match weeks before their xGD stabilises toward reality.

League Table Positions vs xPoints Table

Finally, this third chart compares real league table positions with those created using xPoints-based rankings.

This is a stricter, more volatile test — ranking stability takes longer to emerge. Here’s when each model crosses 80% Spearman correlation with actual league tables:

• Understat → matchweek 16

• Opta → matchweek 19

• StatsBomb → matchweek 19

• Wyscout → matchweek 22

Again, the theme repeats: all four models converge, but at different speeds, and one model consistently needs a few extra weeks to fall in line.

So does xG data choice provider matters? It does …but far less than the xG evangelists (or the xG haters) would have you believe.

7 — Wrapping up

Boom — that was ‘Not All xG Is Created Equal‘ Python Football Review style.

I guess that despite StatsBomb’s claims that it is the best xG provider in the industry (notably because they consider things like shot height, nearby players, and goalkeeper position), it turns out they’re not that different from Opta after all.

And while we’re on this topic, it’s worth adding another small disclaimer. While preparing this newsletter, I was genuinely baffled by how close Opta and StatsBomb were. All the marketing talk around StatsBomb’s superiority must have gotten into my head. So, to make sure there wasn’t an error in my data, I tried to double-check whether my StatsBomb values were accurate.

I had a hard time finding another source of StatsBomb match-level data, so I scoured the internet and eventually stumbled upon a YouTube video dating back to April 2020 reviewing Statsbomb data (which at the time was hosted on Fbref) for Dortmund’s 2019/20 season.

Comparing those numbers to mine revealed some differences:

• Match 1 (vs Augsburg):

  • My data → 2.7 vs 0.7

  • Statsbomb (as of 2020) → 2.4 vs 0.7

• Match 2 (vs Köln):

  • My data → 1.4 vs 0.7

  • Statsbomb (as of 2020) → 1.7 vs 0.8

• Match 3 (vs Union Berlin):

  • My data → 1.9 vs 1.9

  • Statsbomb (as of 2020) → 1.8 vs 2.1

This makes me think that StatsBomb retro-updated their xG model (all providers revise historic values occasionally), which means that my data captured an earlier version of their feed.

Having said that … here are a few personal takeaways:

1. I was surprised by how close Opta and Understat are

Understat isn’t really a “provider” in the formal sense, and I still have no idea where they source their raw data. So either they rely on Opta (somewhat), or they built a very similar model — which seems like the more plausible explanation. Either way, Understat remains a great free resource that’s reliable enough for most purposes.

2. Wyscout’s reliability (or lack thereof)

Wyscout never had a reputation for best data in the industry. Still, I always interpreted that to mean they might struggle with less popular leagues — lower coverage, lower interest, fewer people checking and validating data, etc.

What surprised me, though, is how differently they behave in the five biggest and most well-covered leagues. I expected their model to track much more closely with Opta and StatsBomb.

As we saw in the cumulative plots, they eventually converge — but along the way they produce more outliers than the others. If you’re using this for predictive modelling, that variance could change a few odds that your model produces.

3. xG models converge over the season — but match-to-match variance can be big

Over the long run, the models tell almost the same story. But game-by-game? In 25% of matches, at least one provider disagrees with the others about who “won” the xG battle (based on my simple xG-winner classification). This looks like a big diasgreement to me.

4. Understat data correlates best with actual team performance

I was genuinely surprised to find that Understat consistently leads the pack when it comes to convergence to actual team performance — whether you look at points, rankings, or xG differences. It’s almost ironic: the only source in the comparison that isn’t a formal data provider ends up aligning with reality the fastest.

What was your biggest takeaway?

I’d genuinely love to hear it.

The natural follow-up is obvious: shot-by-shot analysis. Instead of comparing match-level aggregates, compare each provider’s probability for each individual shot. If that’s something you’d like to see in a future edition, drop a comment — I’d be happy to expand this series.

Thank you for reading until the end.

See you next week,

Martin

A few weeks back, Aurel Nazmiu shared a great visual showing when the Premier League table stabilises during the season.

I loved it for three reasons:

1. It shows you don’t need fancy, complicated charts to do good analytics.

2. This seemingly simple graph hides a surprising (to a beginner) amount of data wrangling beneath the surface.

3. And when you try to recreate it yourself, you naturally start asking deeper questions you never considered when you first saw the figure — like what type of correlation should I use, and why does that matter? (more on that below).

Welcome to The Python Football Review #016.

In today’s edition, we’ll replicate that figure, then extend it to Europe’s top five leagues to see which ones settle earlier than others.

And along the way, you’ll see that a huge chunk of visualisation actually happens before you ever touch matplotlib — and why the classic (Pearson) correlation doesn’t work well with ranks (so we’ll use Spearman instead).

Let’s dive in.

So, what’s the plan, Martin?

We’ll start by collecting 10 seasons of Premier League results data. Then we’ll wrangle it into a dataset that contains each team’s league position at every matchweek, along with a variable for each team’s final-season position. Once we have that, we’ll calculate the Spearman correlation and finally plot the results.

Without further ado, let’s collect some data.

1 — Collecting the Data

First, we import the libraries we’ll use. Polars for fast, readable wrangling. NumPy for small numeric utilities. Matplotlib for plotting. And SciPy’s spearmanr to compute the Spearman rank correlations between interim and final league positions.

We’ll collect 10 seasons of Premier League results from Joseph Buchdahl’s Football-Data.co.uk — a fantastic open resource with historical match CSVs. With Polars’ read_csv, we can load them directly.

Here’s what the following snippet does:

• Defines the list of the 10 seasons we want.

• Creates an empty list to store each season’s table.

• Loops over each season and loads the corresponding CSV.

• Keeps only the relevant columns: date, home team, away team, full-time result, full-time goals.

• Adds a season column so we can track each row back to its year.

• Appends each cleaned table to our list.

• Concatenates everything into one big DataFrame.

The result is a clean Polars table with one row per match, ready for wrangling.

2 — Wrangling

We start by renaming all columns to lowercase.

Next, we build the team-level data. For each home team, we calculate their goals for, goals against, points won, and goal difference.

We repeat the same for each away team.

Then we stack the two together using a concatenation.

And now we have one row per team per match, containing that team’s goals for, goals against, points earned, and goal difference.

Since our data is ordered by date, we create a matchweek number. Yes — this is a simplification because not all teams play on the exact same day, but over 10 seasons this should not meaningfully impact the results.

In addition to matchweek, we compute: cumulative points, cumulative goals for, cumulative goals against, cumulative goal difference.

This produces a tidy table showing, for every team in every season, how their totals evolve after each matchweek.

Ranking the teams each week

Based on the interim values for points accumulated, goals for, goals against, and goal difference, we create each team’s position for every matchweek. We do this by sorting first by points, then by goal difference, and finally by goals for.

This new cum_pos column is what we care about.

With our clean data ready, we move into the analytical phase. First, we select only the columns we need for the correlation exercise.

Then we create a final positions table by keeping only the last matchweek of each season — these are the official final ranks.

Finally, we join the final positions back to all matchweeks, so for any given matchweek, we can compare a team’s current position vs its final position.

Correlation over time

Next, we compute the correlation for each matchweek. The loop:

• takes matchweek k

• extracts all team positions at that point

• compares them to the final table

• computes Spearman’s ρ

Why Spearman and not Pearson (the classic correlation you first learn at school)?

• Pearson works on raw numeric distances — it assumes linear relationships, not ranks.

• Spearman works on ranks, which fits league tables perfectly. League positions are ordinal, not numerical — finishing 1st vs 2nd is not the same “distance” as finishing 10th vs 11th.

So Spearman is the right choice for football standings.

3 — Plotting

Once correlations are computed for all weeks, we plot them.

In competition economics (my day job), an 80% threshold is often used as a way to summarise a relatively strong effect or a reliable sample. I think it also links loosely to the Pareto idea — the 20% of factors that deliver 80% of the results. Regardless, for the purposes of this small article, we’ll treat 80% as the level where things start to “stabilise” (my newsletter, my rules).

So the natural question is:

At which matchweek does the Premier League’s correlation exceed 80%?

Answer: Around Matchweek 10.

By that point, the table already starts to resemble its final shape to a meaningful degree. A few observations stand out:

• The 70% threshold is crossed as early as Matchweek 6.

• But it’s only around Matchweek 10 that the league passes the 80% mark — our “stability” line.

• And interestingly, crossing from 80% to 90% takes quite a bit longer. It’s only after roughly Matchweek 20 that the Premier League reaches the 90% correlation level.

• The final 10% — from 90% to 100% — takes about 18 additional matchweeks, almost half the season.

Early structure forms quickly. True stability takes time.

And what about the other Big 5 leagues?

It turns out:

• Ligue 1 crosses the 80% threshold only after Matchweek 15, and reaches the 90% mark around Matchweek 25 — a bit late.

• Serie A and the Bundesliga are the earliest to stabilise among the Big 5, passing the 0.8 threshold at Matchweek 9 — though La Liga and the Premier League aren’t far behind.

Boom — that was the behind-the-scenes look at when league standings actually settle.

You’ve now seen the amount of wrangling required to produce a graph that looks deceptively simple. You’ve seen the kinds of questions you end up asking only once you start working with the data (you’ve probably heard of correlation — but maybe not the difference between Pearson and Spearman). And you’ve learned that Ligue 1 takes its time to stabilise, while Serie A is the quickest of the Big 5.

This whole exercise reminded me of one of my favourite truths about (football) analytics: the best insights show up only once you’re deep in the weeds doing the work.

On paper, this looked like a trivial problem: “Compare matchweek positions to final positions. Plot the correlation.” Easy.

But once I started building the table — lining up matchweeks, ranking teams, joining final positions — a bigger question surfaced:

“Wait… what exactly is being correlated here? Do distances between positions even mean anything? No. So why am I reaching for Pearson? This is a ranking problem — of course Spearman is the right tool.”

You only see the true shape of a problem once you’re inside it.

Thanks for reading until the end.

See you next week,
Martin

As usual, you can grab the code below. The part that downloads all five leagues and plots the figure is included inside.

Grab the Code

Simply download it, open a Google Colab session (if you don’t have Python installed), and run it line by line to replicate the analysis. And if you’re feeling adventurous, try switching the leagues and exploring beyond the Big 5.

Hint: you can use keys like E1 (Championship), E2 (League One), E3 (League Two), I2 (Serie B), SP2 (Segunda División), D2 (2. Bundesliga), F2 (Ligue 2), B1 (Belgium), P1 (Portugal), T1 (Turkey)… just to name a few.

Cheers!

Welcome to The Python Football Review #015.

When it comes to learning Python for analytics, football fans are the best-suited group out there.

Yes — that’s the claim we’re exploring today.

Let’s not waste time and jump straight into it.

Reason #1: Football is the perfect sandbox for the entire data science workflow.

After 10 years in consulting, I can safely say that most business problems only cover two or three parts of the data science workflow (collect → wrangle → visualise → model → deploy). But only rarely, the full spectrum.

Football covers all of them.

It’s rich enough to challenge you, familiar enough to stay fun, and concrete enough to show progress fast.

Every key stage of the workflow appears naturally:

Collection — If you stick around long enough, you’ll eventually touch all the main methods — using community-built wrappers (where most of us start), web scraping, and calling APIs from data providers. It’s a natural progression: from hobby projects to more serious analytical work. Football lets you go all the way — from analyst to data engineer.

Wrangling — Football data is gloriously messy — and that’s a good thing. Even early on, you’ll run into challenges like merging sources where “Man Utd” in one dataset needs to match “Manchester United” in another. This is the unglamorous middle of every real project — and football gives you plenty of practice.

Visualisation — Few domains offer better opportunities to visualise data. From simple scatter plots and line charts to more advanced visuals — xG flow charts, player radars, passing networks, pass sonars — football has it all. In analytics, visuals are often the final product — and football gives you endless ways to master the craft.

Modelling — When it comes to modelling, we can safely say that machine learning is the name of the game in football analytics. Think of the buzzword expected goals — behind it often sits a simple but powerful model: logistic regression. How do teams find replacements for departing players? They could turn to clustering and dimensionality reduction — algorithms that combine dozens of metrics into just a few, then group players by similarity. How do platforms project a team’s chances of winning the title — or even the next game? That’s regression analysis at work.

My point is this: the four main pillars of machine learning — prediction, classification, clustering, and dimensionality reduction — are the same questions fans, scouts, and journalists ask every week.

Deployment — Finally, football pushes you to share your insights — from hobby dashboards to professional tools. Whether it’s tracking trends, explaining tactics, or previewing matches, football gives you a reason to build and publish your work.

When you learn Python through football analytics, you naturally learn to wear all three hats:

• Engineer → collecting and structuring data

• Analyst → finding and visualising insights

• Scientist → building and testing models

That’s what makes football the perfect playground for learning analytics end to end.

Reason #2: The easiest way to learn something? Start with what you love.

I learned that the hard way.

I improved my French through Football Manager. Back when I was a junior economics consultant trying to break into the Paris consulting world, that game became my tutor.

You might think knowing the difference between a Meneur de jeu en retrait (Deep-Lying Playmaker) and a Milieu récupérateur (Ball-Winning Midfielder) wouldn’t help me professionally — and you’d be right.

But beyond the tactics and jargon, I was absorbing grammar, vocabulary, and sentence structures without even realising it. The learning stuck because it felt like play.

The same pattern repeated in my career.

I perfected my R skills not through formal training, but by combining client projects with late-night forecasting experiments. There’s no better way to master dplyr than trying to fuzzy-match messy data sources full of special characters. Sure, I used R at work — but the real progress came from side projects that didn’t feel like work.

Now, I sharpen my Python through The Python Football Review. At work, it’s only the third tool I use (not my choice!). But I knew one truth: if you don’t use a language — any language — you lose it. The newsletter gave me a reason to keep learning: exploring football questions that genuinely interested me, while staying sharp with new libraries and trends.

Same lesson every time: When you learn through something you already love, the learning sticks.

That’s why football fans have a real head start when learning Python for analytics. You already understand the context and the meaning behind the numbers.

Picking your favourite team as your “dataset” is what most data learners dream of.

Imagine collecting Arsenal’s data from this season. Modelling Arsenal’s title chances using their average xG difference — that’s linear regression in action. Predicting their next match result based on their 6-game rolling form — that’s logistic regression. Grouping Ødegaard, Rice, and Nørgaard by playing style — that’s K-Means clustering.

Suddenly, abstract algorithms become intuitive. When you start with football, the learning never feels forced. It’s relevant, motivating, and — most importantly — sustainable.

As a fan, you already have the perfect excuse to get into Python. The subject you love is the best teacher you’ll ever have.

Reason #3: The Feedback loop is fast (and addictive)

The best kind of learning is the kind that gives you instant feedback.

In football, that feedback comes naturally. The data changes every week — new matches, new patterns, new stories. You can test your code, tweak it, rerun it after the next round, and instantly see how things evolve.

That sense of progress keeps you motivated far longer than any textbook ever could.

And then there’s the community.

Football has one of the most active, passionate data communities anywhere online — fans and analysts sharing visuals, models, and insights for every league, every team.

Imagine posting your own shot map after the weekend’s game and joining the discussion around what it means. You’ll get instant feedback — on your visual style, your code, your interpretation — from people who genuinely care about the same questions you do.

That kind of feedback is priceless. It’s fast, constructive, and it helps you improve without feeling like work.

With quick feedback loops and a supportive community, learning Python through football starts to feel like play. You don’t think of it as “practicing coding” — you’re just exploring, visualising, modelling, sharing. And without noticing, you get better every single week.

Boom — those were the 3 reasons football fans are perfectly suited to learn Python for analytics.

Thanks for reading,

Martin

Welcome to The Python Football Review #014.

Today, we’re tackling a question I’ve been thinking about a lot lately: What are the biggest mistakes beginners make when they start learning Python for football?

Let’s dive into five of them and see how beginners can move past them.

Mistake #1 — Starting without a roadmap

Python is everywhere — websites, apps, machine learning, and of course, football analytics. The good news: there are thousands of tutorials. The bad news: that’s the problem.

You search online and you’re hit with two extremes: a 5-hour Python bootcamps made for software engineers or overly technical research papers / GitHub projects written by data scientists for other data scientists. And on rare occasions, you’ll find a single video showing one cool football visualisation or model — but nothing structured, nothing that takes you from start to finish.

Both are valuable. Neither are designed for a beginner who just wants to answer a simple football question like:

“How many points is my team projected to win based on their current form?”

So you bounce from tutorial to tutorial, learning random bits of Python without ever completing a project. The overwhelm quickly turns into paralysis:

“Am I supposed to learn all of Python before I start analysing football?”

No.

In the beginning, you don’t need all of Python — you need the minimum viable skills that let you move through the four phases of a project: Collect —> Wrangle —> Visualise —> Model.

Just enough to complete something real — fast.

Once you understand the framework and have a tiny toolkit for each phase, you stop wandering and start building. And that brings us to the next mistakes — one per phase — starting with:

Mistake #2 — Getting stuck at data collection

Few things derail a beginner faster than getting stuck at step one — finding usable data.

Many YouTube tutorials gloss over this stage because collecting data can be a pain, but in real projects you have to source it yourself. The bottleneck usually looks like one of two things:

• you lose days trying to build scrapers (often with ChatGPT’s help), or

• you simply don’t know where to find analysis-ready data.

So you copy someone’s code… and it breaks. Now you’re left wondering: Did the website change? Is my environment broken? Did the site upgrade its bot protection?

You have no idea where the problem is, and the frustration kills your momentum.

The easier path — especially when starting out — is to use reliable shortcuts. In football analytics, those shortcuts are community-built wrappers like soccerdata and scraperfc.

These packages exist because people in the analytics community created them so you don’t have to build scrapers yourself. They let you load team, match, and event data across multiple leagues in minutes, using simple one-liners.

Spend your time analysing football — not fighting HTML (at least not in the beginning).

Mistake #3 — Letting pandas slow you down

You’ve finally collected your football data. Naturally, you want to jump straight to the fun part — plotting visuals, building models, proving your point.

Not so fast.

In real projects, the bottleneck isn’t the chart or the model. It’s getting your data into a shape where those things even work.

That stage is called wrangling — cleaning, transforming, structuring — and seasoned analysts joke that it eats 80% of every project. It’s funny only because it’s true.

Sure, some paid feeds or public repos give you neat, tidy tables. But the moment you combine sources or scrape data yourself, chaos appears: missing values, inconsistent team names, wrong data types, tables shaped like abstract art.

Every tiny issue compounds. This is where frustration spikes.

For years, the default tool was pandas — every tutorial on Earth seemed to start with: import pandas as pd.

And soon you’re staring at code like:

And thinking: “How am I supposed to remember this?” Welcome to pandas bracket soup.

The Fix? Use Polars – a modern, readable and fast library. Instead of nested brackets and constant index resets, Polars reads like plain English:

If your wrangling code is readable, you learn faster.

Instead of wrestling with syntax, you stay focused on the football question.

Mistake #4 — Jumping into advanced visuals without mastering the basics

You’ve collected your data. You’ve wrangled it into shape. Now comes the part that feels the most rewarding: turning numbers into visuals.

But this is where many beginners hit a wall.

You search GitHub, find someone’s beautiful shot map or radar chart, copy the template … and then spend two hours tweaking fonts, colours, and layout. You’re focussed on styling instead of learning fundamentals.

The real bottleneck isn’t Python syntax. Most visuals take just a few lines of code. The bottleneck is not knowing what to plot, or why. “Is this a scatter? A bar? A line? A radar?” So you jump into advanced football charts without first learning the basics.

Here’s the thing nobody explains: A shot map is just a scatter plot on a pitch. An xG flow is just a line chart over time. A radar is just a bar chart, arranged differently.

If you understand the fundamentals (scatter, line, bar etc.) — you can build the football-specific visuals later with (greater) confidence.

So focus on the fundamentals first, templates later.

Start with Matplotlib to learn the core chart types and how to shape data for them. Then add mplsoccer to place those charts on a football pitch when you’re ready.

Mistake #5 — Treating modelling like black-box magic

You’ve gathered your data, wrangled the mess, and even sketched a few charts. Now every football guru on Twitter is going to ask, “Great—so what does this mean for the next match? The next season? The next transfer?”.

Welcome to data modelling: the stage where history turns into actionable predictions … and the stage every beginner thinks is the whole show.

Newcomers often picture this step as black-box AI magic—machine learning this, neural networks that. In reality, most useful models boil down to a few clear ideas and a single line of code that does the heavy lifting. The hard part isn’t running a model; it’s framing the question, choosing the right tool, and interpreting results without fooling yourself.

The biggest trap beginners fall into is jumping straight to complex algorithms without understanding the mechanics or the “why” behind them.

The truth is, if you focus on just one algorithm per key machine learning task, you’ll cover 80% of what you’ll ever need.

In practice, that means mastering:

• Two supervised algorithms — Linear Regression (for predictions) and Logistic Regression (for classifications).

• Two unsupervised algorithms — K-Means Clustering (for grouping) and PCA (for dimensionality reduction).

Those four alone will prepare you for the vast majority of real-world problems you’ll face. Once you understand the mechanics — how to run them, how to read results, and how to apply them — then you can move on to the fancier stuff like ensemble models or XGBoost.

With scikit-learn, most of these take a single line of code. The real work lies in framing the question and interpreting the output.

And speaking from experience — you’d be surprised how often, even in the business world, a simple linear regression delivers great results.

Just remember: simple is smooth, and smooth is fast.

You don’t need neural networks to start. You need a question → a simple model → an insight.

Boom — those were the 5 biggest traps beginners fall into when learning Python for football.

Thanks for reading,

Martin

And it’s not the first time I’ve stumbled across Elliot Anderson’s name this season either.

So, since I’m officially back (after a long summer break), I thought — why not do a quick, improvised Python Football Review?

Welcome to The Python Football Review #013, where we’ll recreate Sky Sports’ figure in just a few minutes using Python.

Step 1 — Collecting the Data

We’ll start with the basics. Install soccerdata to scrape data from Opta via FBref, and import it alongside polars (for easy wrangling) and matplotlib (for plotting).

From FBref, tackles live in the defensive stats, while progressive passes come from the standard stats. No, FBref doesn’t have line-breaking passes, but progressive passes are the closest we can get — so we’ll take them and move on.

Step 2 — Wrangling the Data

soccerdata returns pandas DataFrames, but I prefer working in Polars for its clarity. So, we convert everything to Polars, rename our columns of interest, and keep only what we need.

Next, we join the two datasets, create tackles per 90 and progressive passes per 90, and filter for midfielders only.

After this step, we’re left with a clean DataFrame of 102 midfielders — ready to visualize.

Step 3 — Visualizing

Now that we’ve got our cleaned dataset, it’s time for making the visual.

We’ll create a simple scatter plot, where each dot represents a player — progressive passes on the x-axis, tackles on the y-axis.

And here is our scatter plot.

Right away, Nottingham Forest’s Elliot Anderson jumps off the chart — an aggressive ball-winner (26 tackles) and an exceptional progressive passer (89 progressive passes).

If you look closely at Sky Sports’ version, you’ll see their metrics are per 90 minutes.
So, let’s replicate that too.

Once we adjust for minutes played, Anderson still stands out — averaging 8.9 progressive passes and 2.6 tackles per 90 minutes. But he’s no longer quite the outlier he appeared to be in the first figure.

What happened? Well, some players in the dataset likely have played far fewer games than he has — which naturally inflates their per-game averages.

So, once we account for that (for example, by keeping only players who’ve played at least six matches), we end up right where we expected to be from the start.

This small exercise is a great reminder of what matters when visualizing data.
It’s not just about plotting numbers — it’s about making sure the sample is representative. Because if you include everyone without context, outliers can easily distort the message.

It’s also a reminder that with the right filters, you can subtly shape which stories (and which players) stand out (I am not saying that’s the case here). That’s why even Sky’s version says “selected midfielders.” Filtering matters. (And kudos to them for making that clear).

Anderson is an exceptional player. Sky Sports are a trusted source. This little project simply serves as a reminder of the dos and don’ts in data visualization. Here, everything is perfectly valid — but it also shows how, depending on the filters you use, the picture can shift.

Here’s the same figure again, this time keeping only players who’ve played at least three full matches — which is still a fair cut-off (roughly 30% of the season so far).

So Curtis Jones for Player of the Season? Maybe not (yet?) … but you get the point.

Wrapping Up

This was a small but fun reminder of two things:

1. With Python, you can recreate Sky Sports-worthy analytics visuals in minutes (even if the Matplotlib aesthetics we used here still lag a bit behind).

2. Data always needs context — even the cleanest chart can mislead if you forget to filter carefully. (Not that I’m saying there’s one “proper” filter here — but you see what I mean)

And with that, we wrap up this short, improvised edition of the Python Football Review.

Ah — it feels so good to be back.

Thanks for reading,

Martin

P.S. As usual, you can grab the code below.

Grab the Python code

Welcome to The Python Football Review #012 — and to our ongoing “in plain English” series.

Today, we’re zooming in on data visualisation — what it is, why it matters, and how it fits into a typical football analytics workflow. Even though the term kind of explains itself, there's more nuance than you might think.

There’ll be no Python code in this one — just ideas, insights, and some visuals to help you build intuition.

Quick heads-up

I’m working on a Fast-Track Guide to Football Analytics with Python — designed to cut through the fluff and get you building your first football data project fast.

If templates and walkthroughs sound like your thing, join the waitlist below. It’s launching in early September.

Join the Wait List

Alright, let’s get into it.

A (good) graph is worth a thousand words?

Why do we make graphs?

Seems obvious, right? To visually represent our analysis.

But here’s the catch: in the rush to produce slick-looking visuals, we often forget the actual point of a graph — to reveal patterns and problems that numbers alone can’t show.

Allow me to introduce you to...

Anscombe’s Quartet: When Statistics Lie

In 1973, statistician Francis Anscombe made a powerful point.

He created four datasets — now known as Anscombe’s Quartet — that all had nearly identical statistical summaries: same mean, same variance, same correlation, same regression line.

But when plotted, they looked radically different.

Each quadrant tells a different story:

• Top Left: Linear Relationship

  What you’d expect. A clean trend. Visuals and stats agree.

• Top Right: Non-Linear Relationship

  The correlation exists, but it’s not linear. A regression line would mislead.

• Bottom Left: Outlier Distortion

  One rogue point skews the analysis. You’d miss this without a plot.

• Bottom Right: High-Leverage Point

  A single point creates the illusion of a relationship. Remove it, and it vanishes.

Lesson: Always visualise your data. Don’t trust the stats alone.

Subscribe now

So what is data visualisation, really?

In theory, data visualisation is the use of graphs and figures to communicate the insights hidden in your data.

In practice, it serves two different purposes (especially in a football analytics workflow):

1. Visuals before modeling — to explore and clean your data.

2. Visuals after modeling—to communicate your findings to others.

Let’s unpack both.

Data Visualisation Before Modeling

Before you train any model — or even start building one — you should always look at your data visually.

Why?

• To spot outliers

• To see patterns that stats might hide

• To double-check missing values, or duplicates

• To rethink aggregations (maybe total annual wage makes more sense than average?)

This “visual inspection” often sends you back to the wrangling phase to fix or reshape your dataset — and that’s a good thing.

Most-used graphs at this stage:

• Scatter plots – Show relationships between two numeric variables

• Histograms – Show the distribution of a single variable

• Box plots – Highlight outliers and spread of a variable

• Line plots – Track a variable over time

• Bar charts – Compare categorical groups

These are your exploratory workhorses — the ones you’ll return to over and over.

The Python Toolstack? Usually just matplotlib or seaborn— one line of code gets you 80% of the way there.

Data Visualisation After Modeling

This is where data visualization becomes the final product.

You’ve done the heavy lifting. Now it’s time to show your insights — clearly and convincingly.

And football has its own set of specialized visuals for this:

• Radar charts / Pizza plots – Compare player profiles across attributes

• Pass maps – Show passing patterns or clusters

• Pass networks – Visualize team structure and ball movement

• Heat maps – Show player or team activity zones

• Shot maps – Reveal shooting tendencies and goal threats

• xG Flow charts – Track expected goals across match time

The Python Toolstack? Usually matplotlib and seaborn again, combined with mplsoccer, a library tailored to football analytics.

A Few Rules of Thumb From 10 Years in Consulting

Rendering a simple figure is, in most cases, a one-liner. The real challenge is almost never the plotting itself — it’s getting your data into the right format and shape.

I told you wrangling was important (if you missed the football data wrangling issue, grab it here).

Of course, you still need to get familiar with different visualisation libraries and functions. But that’s generally the easier part.

The Real Bottlenecks

There are two major hurdles that beginners face when visualising data:

• Not knowing what you want to show.

This is the hardest part. Especially early on, it's easy to feel lost — you have the data, but you don’t know what story to tell or what figure would best show it.

Here is a thought-starter:

• Not knowing how to wrangle the data into shape.

You might have an idea (“I want a scatter plot showing Shooting Goals Added/90 vs xG/90 per player”), but you can’t quite get the DataFrame to that point. Wrangling data is a fundamental skill that will follow you everywhere.

For beginners, the easiest way to get started is with polars — lightning fast, simpler syntax (the code reads like a recipe), and easy to revisit after a break.

If you get past these two — that is, you know what to graph and you can wrangle your way into the right shape — you’ve done 80% of the visualisation work.

The Last 20%: Branding and Beautifying

As with most things in life, going from 80% to 100% takes disproportionate effort. It’s where diminishing returns kick in. But let’s not kid ourselves — a beautiful figure often stands out because of:

• Clean labels and titles

• Thoughtful color palettes

• Well-placed annotations

• Consistent fonts and styling

Take a look at the most popular football analytics accounts on Twitter: they have a recognisable aesthetic. That’s their visual branding — a consistent combination of font choices, color themes, and annotation styles.

As a beginner though, your job is not to perfect every tiny detail. Your job is to get the fundamentals right — and trust that polish will come with time.

The good news? Once you design your own visualisation template (or adapt an existing one), you rarely need to touch it again. That’s the power of templating.

Boom — that was data visualisation fundamentals in plain English.

Data visualisation isn’t just about making pretty charts.

It’s about thinking clearly, communicating honestly, and seeing what’s really there — even when the stats try to tell a different story.

If you enjoyed this post, consider sharing it with someone who might find it useful.

If you’d like access to Python football templates, stick around — or join the waitlist for the upcoming Fast-Track Guide to Football Analytics with Python.

Join the Wait List

Either way, deep dives are coming.

Comments and shares are always appreciated.

Thanks for reading—see you next Thursday!

Martin

The Python Football Review

Welcome to The Python Football Review #011.

Seasoned analysts will tell you that 80 % of any football data project is spent on one thing: wrangling. If the term is new to you, think of it as the combined art of cleaning and transforming raw tables so your analysis doesn’t fall apart later.

In this issue you’ll learn:

• what data wrangling really means,

• why even “clean” datasets still trip people up,

• the common bottlenecks that beginners face, and

• the one Python library that makes wrangling faster—and far less painful.

Enjoy!

Before we dive in — quick heads-up.

I’m working on a Fast-Track Guide to Football Analytics with Python — designed to cut through the usual beginner roadblocks and get you hands-on, fast.

It’s packed with ready-to-use templates and practical case studies, so you can skip the fluff and start exploring football data with confidence.

Interested? Join the waitlist below:

Join the Waitlist

Okay, let’s dive in.

1 – Cleaning

Last week, you learned the four ways to collect football data. If you missed that issue, you can catch up here. Once you’ve collected the data, your next move is to clean it.

But wait, Martin—isn’t the data I just downloaded already clean?

It’s tempting to think so. If your feed comes from an internal pipeline, a paid JSON API, or a trusted public hub like FBref, the tables usually look pristine. Yet they almost always hide little traps:

• A handful of xG values are missing—models choke on blank rows.

• Brighton appear as “Brighton”, “Brighton & Hove Albion” and “BHAFC” across seasons. Pick one or your merges will explode.

• Dates sneak in as plain text; numeric columns arrive as strings. Try plotting those and see what happens.

Long story short: “collected” does not equal “analysis‑ready.” The safest mindset is to assume every dataset is dirty until proven clean.

Once you’ve fixed the nulls, unified names, and straightened data types, you can move on to the fun part: transforming.

Subscribe now

2 – Transforming

Cleaning makes the data safe; transforming makes it useful.

Here’s what usually happens in this stage:

• Zoom in – Slice the universe down to what matters: maybe just Premier League matches since 2014/15, or only Arsenal home fixtures, or every shot taken after the 75‑minute mark.

• Create new metrics – Raw columns rarely answer football questions on their own. You might turn xG and minutes into xG per 90 min, combine passes into a possession percentage, or compute contributions as goals plus assists.

• Summarise up a level – Event data might be often too granular for the question you’re asking. Aggregate it until each row matches the decision-making level you care about: turn individual shots into total xG per match or combine match records into team-season aggregates.

• Reshape the table – Statistical models prefer “one row = one observation.” That could mean pivoting long (each team a separate row). A graph may require « one column = one observation » and that could mean pivoting wide (each team in its own column). Switching formats is routine.

• Stitch multiple sources together – Want to add betting odds or other non-performance data? You’ll merge tables on date, match ID, or team name; uniform naming from the cleaning step is what keeps these joins from exploding.

• Scale where needed – Some algorithms behave better when inputs sit on a common scale. Simple min‑max scaling is often enough.

A single project may loop through these tasks several times: aggregate, spot an outlier, go back, filter differently, aggregate again. The end‑product is one tidy, logically structured DataFrame you can feed straight into a model or visual.

The goal is simple: produce a single, well‑structured DataFrame your model, chart, or dashboard can consume without complaint.

Cleaning + transforming = wrangling—and that’s where 80 % of real project time goes.

Told you it was important.

3 – How do you actually wrangle data in Python?

For years the default answer was pandas.

Pandas gives Python a DataFrame object (Python itself has none), and every tutorial on Earth seems to start with import pandas as pd.

But here’s the trouble: the API is showing its age.

You juggle as_index=False, fight the dreaded SettingWithCopyWarning, and chain methods that read nothing like plain English. Great library—just (dare I say it) not beginner‑friendly.

A newer option, polars, fixes all three pain‑points:

• Faster – Under the hood it’s Rust, so large tables fly.

• Cleaner syntax – Verbs like select, filter, with_columns read like a recipe.

• Short learning curve – Fewer edge‑case arguments, no copy‑view headaches.

If someone offered you standard vs. faster, clearer, easier to remember, which would you pick?

Exactly.

Here’s a sample Polars code. For this exercise, we’ll use a 2023/24 Fantasy Premier League dataset available on Github that contains ~ 30,000 rows, where each row records a single player’s stats for one Premier League gameweek. The data contains 41 columns covering everything from goals and assists to minutes played, xG, xA, and more.

If we want to wrangle the data to discover Arsenal’s top contributors in goals and assists, here’s how we could do it with Polars:

A quick Polars demo

Try reading that line by line:

1. read_csv – load the file (using its URL).

2. select – keep only the columns we need.

3. filter – keep only the Arsenal rows only.

4. with_columns – add assists + goals_scored as contributions.

5. group_by / agg – group by each player and aggregate his total contributions.

6. sort – rank the players by their contributions and show the top five.

7. head - show the top 5 performers.

That’s the entire story—no temporary variables, no lambdas, no warnings. Swap select for merge or pivot and you’ve covered 80 % of day‑to‑day wrangling.

The point of this demo is to show that Polars reads like a recipe (it has tons of other advantages but that’s a story for another time). Even if you’ve never written a line of Python in your life, you’ll have no trouble following it. Better still, once you type it out, the syntax sticks—because you use clear, verb-style commands.

Next time you need to wrangle data, the steps will come right back to you, streamlining your workflow like nothing else. Speaking from experience here.

Now, polars won’t make every wrinkle disappear, but it removes a lot of the boilerplate that trips newcomers. Learn a dozen verbs and you’ll slice through datasets while everyone else is still Googling “Pandas groupby keeps index true/false?”

(And yes, Pandas is still the industry standard; we’ll look at bridging the two in a future issue.)

4 – Rules of thumb from a decade in data consulting

1. Choose a library you can walk away from and still remember.

   If you might take a few weeks off, Polars’ verb‑style API is far easier to pick up again than Pandas’ bracket soup.

2. Assume every dataset is messy.

   Even “premium” feeds hide quirks—extra spaces in names, dashes instead of NaN, silent duplicates. Treat cleanliness as a hypothesis you must test, not a fact.

3. Verify first, trust later.

   Quick descriptive stats (min, max, unique counts) expose impossible values before they poison your model.

4. Name things clearly and consistently.

   Lower‑case, snake_case, no spaces: team_id, match_date, xg_total. Future‑you—and your join keys—will thank you.

5. Interrogate every column.

   A header can lie. Ask “What exactly does possession mean here?” before you publish a chart based on it.

6. Debug on a snack‑size sample.

   Pivot won’t run on 100 k rows? Slice ten rows, fix the issue, then scale back up. Small chunks reveal problems fast.

Stick to these habits and wrangling becomes routine rather than a recurring nightmare.

Boom—that’s data wrangling in plain English for absolute beginners.

If this issue helped, feel free to pass it on. You now understand why most people stall at the wrangling stage—and how to jump ahead of 90 % of them.

Share

I’m still tweaking the format, so hit reply and tell me what you’d like more (or less) of: shorter bites, deeper dives, extra Python snippets, or broader football concepts?

My goal is to build this newsletter with you, not just for you.

See you next Thursday,

Martin

The Python Football Review

Welcome to The Python Football Review #010.

Today we’re tackling the unglamorous but absolutely critical first step in any football analytics project: collecting the data.

By the end of this issue you’ll know the 4 main ways to source football data—and how to start pulling it with only a few lines of Python, all explained in plain English.

Before we get started, just a quick heads-up.

I’ve started working on a beginner-friendly Fast-Track Guide to Football Analytics with Python.

It will be packed with useful templates, practical case studies, and easy-to-follow explanations.

If you’d like to be the first to know when it launches (and maybe even grab an early-bird bonus), you can join the waitlist below:

Join the Waitlist

Okay, so grab a coffee, and let’s dive in.

What Data Collection Really Means

Most coding courses hand you spotless CSVs. Real life doesn’t.

Unless you work somewhere that pipes cleaned match feeds straight to your desk, you are the data engineer. Your job is to move raw numbers—from a website, an API, or a database—onto your machine in a format you can actually use.

Ian Graham, Liverpool’s former Director of Research and the brains behind the first in-house analytics department in the Premier League, recalls sprinting into the office the morning after their 4-0 comeback against Barcelona just to open an analysis-ready match file. Lovely—if you have a dedicated data engineering team.

Most of us don’t.

So here’s how to do it yourself.

1—Manual Copy

Sometimes the fastest route is staring you in the face: open Understat or FBref, copy-paste the table into Excel, job done.

There’s nothing technically tricky here—other than finding exactly what you need.

But manual work can’t be automated, and it doesn’t scale.

Thank you, Captain Obvious.

Still, for a quick sanity check or a one-off chart, copy-paste is quicker than spinning up a full scraper.

You can do even better: never start copying until you’ve checked GitHub or Kaggle.

Chances are someone has already posted the dataset you need. If you can read_csv() or read_html() a clean file in a single line, take the gift and run.

2—Web Scraping

The data you need isn’t always gift-wrapped. It may sit behind dynamic tables, dropdown menus, or JavaScript calls that no public wrapper touches. Web scraping is the art of writing a script that visits a page, finds the right pieces of the markup, and copies the numbers to your machine.

In practice you:

1. Request the page’s HTML.

2. Parse its nodes (individual tags such as <tr> or <td> that hold text).

3. Extract what you need and save it to a DataFrame.

Expect a learning curve though.

You’ll juggle CSS selectors (mini-queries like .table-row > td:nth-child(3) that tell Python “grab the 3rd cell in each row”), deal with cookies and CAPTCHAs, and respect robots.txt so you don’t hammer the host server.

Typical Python toolkit

• requests + BeautifulSoup for quick and clean for static pages and simple tables.

• Selenium for spinning up a headless browser so you can click buttons, open dropdowns, and wait for JavaScript to load.

• pandas.read_html() – a one-liner that sometimes grabs simple tables without extra code (You can check out ’s brilliant explanation on YouTube).

Scraping could fill a course by itself, but even basic skills pay off: once you automate a tricky site, the data updates are yours forever.

Now, if you’d rather skip copy-pasting (too basic, not scalable) and avoid the overhead of building custom scrapers (steep learning curve, time-consuming upkeep), you have two smoother routes:

1. Pay for polished feeds—exactly what most pro clubs do. Providers like Opta, StatsBomb, or Wyscout deliver match files that are already cleaned and documented.

2. Lean on community wrappers—open-source libraries that pull multiple seasons of advanced metrics with a single line of Python.

We’ll look at the paid option first, then wrap up with the beginner-friendly community wrappers that most hobby analysts start with.

Subscribe now

3—Paid APIs

Professional setups lean on APIs—stable web endpoints that deliver data in a clean, documented format. (API = Application Programming Interface: a contract that lets your code request specific data from a provider’s server.)

Think of it as web-scraping’s legal, high-speed, fully supported cousin—just one that usually comes with a price tag.

Typical workflow

1. Create an account and grab your personal API key.

2. Read the docs for the endpoint you need—/matches, /shots, /players, etc.

3. Hit the URL, pass your key, and pull back a JSON payload (basically one giant nested dictionary you’ll flatten during wrangling).

Pros

• Clean, consistent schema—no guessing which table cell holds the xG.

• Historical depth and live feeds.

• Official support; if something breaks, you have a help desk.

Cons

• Cost (sometimes eye-watering).

• You still have to wrangle the JSON into tidy columns—just a smaller headache than messy HTML.

Pricing varies. Wyscout is usually cheaper; StatsBomb is the gold-standard and priced accordingly.

If you’re working on a hobby project and don’t need live updates, take advantage of StatsBomb’s free datasets—entire seasons (e.g., Europe’s top-five leagues 2015/16), Arsenal’s 2003/04 Invincibles, Bayer Leverkusen’s 2023/24 unbeaten run, even Lionel Messi’s whole career. Grab them here: https://statsbomb.com/what-we-do/hub/free-data/ or use their Python library statsbombpy.

Ready for the easiest path of all?

Enter community wrappers that fetch those same metrics in a single line of Python.

4—Community wrappers

The football analytics community has blessed us with Python wrappers—packages that hide 97 % of the scraping grunt work.

Instead of copy-pasting from FBref, building a custom crawler, or paying StatsBomb money you don’t have, you can often import a library and fetch the data in a single line.

Flagship wrapper: soccerdata by Pieter Robberechts. Behind the scenes it scrapes several public sources and returns tidy (pandas) DataFrames. With the same package you can tap into

• FBref & Understat: xG, xGOT, xA, xGChain, xGFlow, shot locations, and other advanced team/player stats

• SofaScore, WhoScored, FotMob: line-ups and player ratings

• ClubElo: historical team strength

• SoFIFA: FIFA/FC player attributes

…and more (full documentation here).

Usually it’s one line to set parameters, one line to pull clean data. Simple as that.

Why beginners love wrappers

• Zero scraping headaches—instant gratification

• Perfect sandbox to practise Polars/Pandas before wrestling with raw HTML

Caveats

• Community projects can go stale; endpoints change and packages break—be ready to fork or patch

• Documentation still matters—read it so you hit the right methods and parameters

• Coverage is uneven: plenty of x-metrics for Europe’s top five leagues, far less for lower tiers or niche competitions

Bottom line: start with wrappers. If they cover your use-case, you’re already analysing. If not, fall back on the other three roads: manual copy, web scraping, or APIs.

5—The Python Corner

And finally — here’s the Python code of the day.

It illustrates why starting with wrappers is the fastest and most efficient way for beginners to begin collecting advanced, up-to-date football data.

So, how do you get xG data for Europe’s top five leagues for the past eight seasons?

Easy.

First, install soccerdata (if you haven’t already), and load the library along with a data-wrangling tool — in this case, Polars.

Then, define the scope of your data. You simply call sd.FBref(), set the league to "Big 5 European Leagues Combined", and select the seasons from 2017–18 through the current 2024–25 season. After that, use .read_schedule() — and voilà, the data is yours.

In the code example, we also convert the resulting DataFrame to a Polars DataFrame to take advantage of its friendly, high-performance syntax.

And that’s it — quick and easy, just as promised.

Boom—that was data collection in plain English.

If you found this newsletter helpful, please spread the word! You now know the 4 ways you can get started collecting football data.

Share

I’m still experimenting with the format of the newsletter, so your feedback is super welcome—would you prefer shorter content, longer deep dives, more Python, or more football concepts? Or does this format hit the mark?

My aim is to build a truly practical newsletter together with you.

Until next week,

Martin

The Python Football Review

Welcome to The Python Football Review #009.

For as long as I’ve watched football, I’ve been fascinated by the pundits who sit in match‑day studios and announce exactly how the weekend will unfold.

But are they actually any good—or are we all just blindly trusting their reputation?

It’s time to find out.

This week I crunched every Premier League prediction that BBC (and Liverpool) legend Mark Lawrenson made between 2009/10–2021/22, along with those of his successor Chris Sutton (2022/23–2024/25), and stacked them against the market’s odds. My questions were simple:

• How many matches did they call correctly?

• What would your bankroll look like if you’d followed them with flat‑stake bets?

• Was Lawrenson really biased against Tottenham, West Ham, and Southampton?

And—because this is the Python Football Review—I’m sharing the code at the end so that you can replicate the analysis yourself.

Enjoy!

1 — The Data

I scraped MyFootballFacts for Lawrenson’s and Sutton’s predictions over 16 seasons. In theory, 16 × 380 = 6,080 games; I collected 5,582 predictions—covering 92 % of all fixtures (a few predictions were missing, nothing crucial).

Actual results and average market odds came from Football‑Data.co.uk.

For each match I have:

• the pundit’s predicted scoreline and full-time forecast

• the real scoreline and outcome

• market‑average odds for home win, draw and away win

That’s enough to run a profit‑and‑loss simulation with a simple 1‑unit flat‑stake strategy.

2 — Simulation Results

So what would have happened if we placed a single‑unit bet on all 5,582 forecasts?

The pundits called 2,862 matches correctly (51 % win rate), resulting in a +14.5‑unit profit on a 1‑unit stake per game—an overall rate of return (ROR) of +0.3 % (14.5/5582) across the 16‑season sample.

Now that’s a surprise. Honestly, I expected a loss.

No disrespect, but making money in betting is about value, not simply picking winners, and punditry is (mostly) about predicting winners.

Having said that, a 0.3% ROR over 16 seasons is nothing to brag about. I mean the pundits were basically treading water—just about breaking even.

Nothing more, nothing less.

Individual performance

• Mark Lawrenson: 4,450 forecasts → 2,289 correct predictions (51 % win rate) → +47.6 units (+1.0 % ROR). He started strong, dipped to –60 units, then clawed his way back and spent most of the time above zero.

• Chris Sutton: 1,132 forecasts → 573 wins (51 % win rate) → –33 units (–3 % ROR).

Sutton hasn’t found the same luck (yet?). After 1,000 forecasts he’s 33 units down. For context, at the same stage Lawro was –60, so don’t write him off just yet.

Subscribe now

3 — Should We Be Impressed with Lawro’s Record?

Let’s be real: a 1 % ROI over 13 seasons is nothing to brag about. You’d have earned more interest parking the cash in a half‑decent savings account.

Remember, this is after decades of insider contacts, professional playing experience, and BBC resources.

Lawro’s Predictions began as a TV segment and became a BBC Sport website staple, regularly generating hundreds of thousands of page impressions each week—peaking at 1.2 million when Rick Astley guested over Christmas 2020 (BBC).

Now, that’s a lot of interest for a 1 % return over 13 years of predictions, wouldn’t you agree?

It’s not really about betting, of course, but many fans still treat the column as a tipping service.

Any experienced bettor will tell you:

• Profitable betting is about value, not just calling winners.

• Blindly following tipsters (or pundits?) won’t get you far. If they’re right, odds adjust and the edge disappears; if they’re wrong, your bankroll suffers.

• If betting were easy money, it wouldn’t be legal. Harsh but true. As Lawro himself once joked:

“If I honestly thought I could accurately predict the results of football matches, I wouldn't be here, freezing my backside off. I would be in Barbados, in Sandy Lane hotel.”

4 — Did Lawro Have Biases?

Before we get to the Python corner, let’s tackle a complaint Lawro heared a lot. Fans of Tottenham, Southampton, and especially West Ham have long claimed he’s biased against them.

So here’s a small analysis we can run: grade only Lawrenson’s for/against calls at average odds.

• If his picks beat the market (i.e., show a positive ROR), you could argue his forecasts were broadly justified.

• If they fail to beat the market, critics have a case that he under-performed—wilfully or not—on certain teams.

Yes, this is a simplification. A positive ROR might just reflect a few mis-priced games, while a negative one could be the product of small samples, long-shot variance, or statistically insignificant results. The goal here is insight and a bit of fun.

So how did his predictions fare for those clubs?

The table below shows the simulation results for matches involving any of those three teams in which Lawrenson picked a side (draws are excluded).

• Spurs supporters can relax—Lawro was actually better than average on Tottenham fixtures, both in accuracy (60% win rate) and profit (2% ROR)

• Hammers fans: his 53 % hit‑rate and +1 % ROR are almost exactly his long‑run baseline. No real bias either way.

• Saints die‑hards do have a case. He undershot on Southampton, paying out only 46 % of the time and reaching a negative 8 % of returns meaning that over the long term for any 100£ wagered, you’d be expected to lose 8£.

Looking wider, the best teams in his for/against prediction portfolio were Reading (+22% ROR), Watford (20%) and Cardiff (19%).

Blackpool were Lawro’s Trojan horse: only 43 % win rate and a –31 % ROR, followed by Brighton (-16%) and Wigan (-14%).

Bottom line: the “Lawro hates my team” meme is mostly myth—unless you’re a Southampton fan. (And even then, there are five clubs he performed worse against).

5 — The Code

Finally, here’s the Python notebook so you can replicate the analysis yourself.

About 80 % of the work went into scraping the data; I’ll spare you that mess so you can jump straight into the clean, analysis‑ready dataset and do some wrangling. You’re welcome. (We’ll tackle web‑scraping another day.)

Download the notebook and data

If you’re new to Python, a Gmail account is all you need: open a Google Colab session, import the notebook you just downloaded, and run the cells in order. At the second cell you’ll be prompted to upload the data file—select the one you grabbed from the link above—then continue executing cell by cell.

The notebook loads the pre-cleaned data and walks through every step needed to produce the simulation tables.

Credits: Predictions from MyFootballFacts and results/odds from Football‑Data.co.uk (maintained by Joseph Buchdahl).

Boom—that was football pundits uncovered.

If you enjoyed this edition, please share it with a friend.

Share

You now know how accurate football pundits really are, why their tips deserve a pinch of salt, and how to wrangle a dataset to test a pundit’s track record.

Thanks for reading—see you next Thursday!

Martin

The Python Football Review

P.S. Did the results surprise you? Reply below or drop your favourite pundit cliché and I’ll test it in a future issue.

Welcome to The Python Football Review #008!

Last week we crowned football’s greatest finishers. Today we turn the spotlight on goalkeepers and ask:

Who are the elite shot-stoppers?

To find out, I’ll dive into Opta’s post-shot data and examine:

• whether the clean-sheet leaders are truly world-class shot-stoppers

• which names quietly top the Goals Prevented leaderboard

• which fan favourites leak more than they should (brace yourself, we’ve got a World Cup and Euro champions in the list)

A step-by-step Python template is included so you can rerun (and roast) my numbers.

Enjoy!

Quick refresher / disclaimer

If xGOT (expected goals on target) is new to you, start with my 101 primer here. In one sentence:

• xGOT = the probability that a shot on target becomes a goal—ball flight, pace, and placement included.

From there we can build two related keeper metrics:

Example

A keeper faces 105 xGOT and concedes 100 goals.

• GPR = 105 ÷ 100 = 1.05 → he saved 5 % more than the average goalie would.

• GP = 105 − 100 = +5 → over the sample he prevented five goals than the average keeper would.

Of course, shot-stopping is only one pillar of goalkeeping. Distribution, aerial command, and sweeping all matter too—ranking low here doesn’t automatically make anyone a poor keeper, just one who saves fewer shots than the model predicts.

Thank you, Captain Obvios.

Enough talk; let’s see the data.

1 — Scope of the study

For this review we pull eight seasons of Opta post-shot data via Fbref (2017/18 – 2024/25) from Europe’s big-five leagues—Premier League, La Liga, Serie A, Bundesliga, and Ligue 1.

Across the sample we see:

• 122,732 shots on target that yielded 38,877 goals (excluding own goals)

• Those shots carried 37,986 xGOT, so sample-wide Goals Prevented Rate of 0.98—keepers prevented about 2**% less** than the model expected.

• The average shot on target weighed in at 0.31 xGOT, and goalkeepers logged roughly 0.26 clean sheets per 90 minutes.

In plain English: over eight seasons the “typical” big-five keeper is a hair below par—about two extra goals allowed every hundred matches. That gives us a baseline: anyone posting a positive GPR comfortably above 1.00 is bending probability in their team’s favour.

Let’s find out who.

2 — Are clean-sheet leaders world-class shot-stoppers, too?

Okay, over the eight seasons studied, here are the top 10 keepers (minimum 160 games) ranked by clean sheets per 90 minutes.

No surprises here—we see the usual suspects: first-choice keepers at elite clubs.

Across the period, Marc-André ter Stegen tops the list with 113 clean sheets in 247 full matches, or 0.46 clean sheets per 90. He conceded 210 goals from 225 xGOT, giving him a Goals Prevented ratio of 1.07. In plain English, he allowed roughly 7 % fewer goals than the average keeper would have from the same shots—fine margins.

Ederson and Jan Oblak sit second and third at 0.45 and 0.44 clean sheets per 90, while Alisson and Courtois round out the top five. If I’d closed my eyes and guessed, these five names would still have made the cut (though perhaps in a different order).

What really stands out is Oblak’s Goals Prevented ratio of 1.14: his shot-stopping erased roughly 14 % of the goals an average keeper would have conceded. That’s truly elite—though you hardly needed the stat to remember how dominant he’s been. Alisson isn’t far behind at 1.13.

Then come the interesting cases: Ederson at 1.03 and Neuer at 1.02. Both are still above par, yet only marginally so.

Does that make two world-class keepers merely average shot-stoppers?

Rhetorical question—over long samples goals and xGOT tend to converge. More likely, their strengths lie elsewhere: Ederson’s distribution powers Manchester City’s build-up, and Neuer practically invented the modern sweeper-keeper role.

Another working hypothesis — playing behind dominant sides means they face fewer truly testing shots, giving them fewer opportunities to accumulate xGOT (as is also the case for Alisson and Courtois though, so the jury is still out on this one).

The point stands, though: Goals Prevented reframes the conversation by isolating pure shot-stopping, stripping out the protection provided by an elite defence.

So what happens if we flip the question and rank keepers solely by Goals Prevented Rate? Can anyone top Oblak’s +14 %?

Subscribe now

3 — Elite shot-stoppers

Over the eight-season window, 29 goalkeepers posted a Goals Prevented Rate above 1.0. Here are the top performers:

Surprise, surprise: former Nice and PSV guardian Walter Benítez tops the table with an eye-catching 1.15 Goals Prevented Rate. Put differently, he kept out 15 extra goals for every 100 he conceded—across 164 matches. Wow.

Unless you’re a Football Manager addict, this might be the first time you’ve heard his name. Benítez has just moved to Crystal Palace on a free; if he beats Dean Henderson to the No. 1 shirt, he could be a savvy FPL pick.

The metric highlights elite shot-stoppers who don’t enjoy elite defences. Because Benítez faced far more shots than keepers at super-clubs, his clean-sheet rate is a modest 0.30 per 90—still above average, but nothing to headline.

Goals Prevented cuts through that noise.

Rounding out the list are the familiar faces: Oblak (1.14), Alisson (1.13) and Courtois (1.10). Benítez has roughly 100 fewer games than this trio, so a little regression is possible in the future, but topping the chart at all is impressive.

Why it matters?

Scouts can use Goals Prevented to scan global databases for keepers at mid-table sides who are already “adding” goals—spotting the next Oblak (or dare I say Benitez) before everyone else.

Okay, now to the biggest under-performers.

4 — Elite under-performers

Twenty-six goalkeepers in the data set posted a Goals Prevented rate below 1.0. Here are the biggest under-performers:

Lorenzo Montipò (Verona) anchors the table at 0.86, meaning that for every 100 goals he conceded, the average keeper would have conceded only 86. In other words, he handed opponents 14 “free” goals per 100 allowed. Ouch.

Next come journeyman Frenchman Benoît Costil, Union Berlin’s Alexander Schwolow and Sassuolo’s Andrea Consigli all with 0.88.

So far, so ordinary—until you scroll and spot World-Cup winner Steve Mandanda and European-championship hero Rui Patrício, both at 0.94.

You might argue that Mandanda was rarely France’s first-choice and that both keepers are deep into their thirties, so age drag is real. You could also shrug and say “four percentage points off the mean—maybe it’s noise.”

Still, you certaintly didn’t expect national-team players from heavyweight nations to flirt with this list, did you?

I certaintly didn't.

And finally, let’s fast-forward to 2024/25 for a fresh snapshot.

5 — What happened last year?

During the 2024/25 season, 49 goalkeepers logged at least 20 league appearances and finished with a Goals Prevented ratio above 1.0. The chart above shows the top ten.

Yehvann Diouf (Reims) sets the pace at 1.31—Opta’s model says an average keeper would have conceded 31 % more goals from the same shots. Put differently, Diouf erased roughly one goal out of every three the model expected. That’s a hefty spike in form.

Next comes a distinctly Balkan quartet — three Serbs and one Bosnian — Vanja Milinković-Savić (1.29), Đorđe Petrović (1.27), Nikola Vasilj (1.25), and Mile Svilar (1.25).

If Yugoslavia still existed, its national-team coach would have a pleasant selection headache. Well, I guess Serbia’s coach certainly does now.

At the other end of the table, 31 keepers fell below the break-even line. The headline shock sits in the bottom ten: PSG’s undisputed No. 1 Gianluigi Donnarumma slumped to 0.87.

Wait, what?

Despite starring in PSG’s late-stage Champions League run, Donnarumma cost his side roughly 13 % more goals than xGOT predicted over the league season. Maybe supporters forgive that as long as he delivers on the nights that truly matter, but the domestic data is hard to ignore.

And finally, below you’ll find a Python template to reproduce every step of the analysis from scratch.

6 — The Python Corner

Here’s how to replicate everything we just did in Python.

Are you new to Python and programming? Head to Google Colab and open a Python session— all you need is a Gmail account.

Next, grab the notebook I used for this issue by clicking the button below. Inside, you’ll find step-by-step instructions on how to

• pull eight seasons of Opta data from FBref with soccerdata;

• wrangle it with polars; and

• reproduce every insight we’ve just covered.

Download Python Code

Once downloaded, simply import the notebook, launch the code and enjoy.

And there you have it—elite shot-stoppers in a nutshell.

If this issue helped you, please pass it along!

Share

You now know how to rank elite shot-stoppers with xGOT, quantify how much they save their teams, identify the biggest under-achievers, and pull eight seasons of data with Python to analyse all of it yourself.

Until next week,

Martin

The Python Football Review

Welcome to The Python Football Review #007!

Last week we busted the myth of the clinical striker—why even superstars rarely beat their xG by much, and why that’s perfectly fine. The big lesson: only a few players finish well above expectation, and the word “clinical” is messy because xG mixes team service, movement, and finishing into one number.

To study pure finishing we need a sharper tool: xGOT (Expected Goals on Target). xGOT looks at what happens after the ball leaves the boot, so it isolates a striker’s shot placement.

So, in this issue we’ll:

• reveal who the best strikers of the ball are,

• see how far they outshine the average shooter,

• call out the big names who ‘under-perform’ xGOT yet still top the scoring charts (spoiler: two Ballon d’Or winners make the list),

• and give you the full step-by-step Python code to run the analysis yourself.

Enjoy!

Before we dive in, a quick refresher / disclaimer

If xG or xGOT are new concepts for you, you can grab a primer here and here. In short:

• xG (Expected Goals) gauges chance quality—how promising the opportunity was before the shot.

• xGOT (Expected Goals on Target) gauges shot execution—what the striker actually did with the ball after contact.

To isolate pure finishing skill professionals compare xGOT to xG:

• Over-performing xG → the player beats the “average” shooter on identical chances.

• Under-performing xG → could signal below-par finishing or contextual factors we’ll unpack later.

So, for this issue we’ll treat xGOT strictly as a proxy for striking technique. It goes without saying that an elite forward offers far more than goals—target men and pressing forwards change games without scoring—but today we’re zooming in on finishing alone.

Alright, let’s roll out the data.

1 — Scope of the study

For this review we’ll pull Opta’s xGOT dataset—Opta calls it Post-Shot Expected Goals (PSxG)—via FBref. It covers eight seasons of shot-level data from Europe’s top-five leagues (2017/18 – 2024/25) and totals 360,430 shots.

Across those attemps, 5,724 players accumulated a total of 38,883 goals from 39,998 xG and 38,759 xGOT. This means that the:

• Goals : xG = 0.97

Players scored about 3 % fewer goals than the pre-shot model predicted. That near-one ratio is the sanity check we want: over a huge sample, hot and cold streaks cancel out, so xG should line up with reality. The small shortfall suggests that, overall, goalkeepers and imperfect finishing trimmed the total slightly. Or perhaps it’s simply a bit of noise — right in the range where statistical error tends to lie.

• xGOT : xG = 0.97

Post-shot expected goals are at the same 0.97 ratio. Even after accounting for shot placement, the picture barely changes: strikers are still expected to finish just below the pre-shot expectation. This should not surprise you. If xGOT had drifted far from xG, we’d worry about model noise — because over the long term, the two should converge.

• xG / shot ≈ xGOT / shot ≈ 0.11

The typical open-play attempt in the big five leagues offers roughly an 11 % chance of becoming a goal, whether judged before the strike (xG) or after you know its placement (xGOT).

These results echo last week’s findings: over large samples, goals converge toward xG, and the average non-penalty shot in the big five leagues sits around 0.11 expected goals. Numbers differ slightly from last week because that issue used Understat data over an 11-season window.

With the baseline set, let’s see which players top the charts in xGOT ÷ xG.

Subscribe now

2 — The best strikers of the ball

Over the 8 seasons studied, 38 players reached 80+ league goals. Exactly 20 finished with an xGOT : xG ratio above 1.00—meaning their shot placement added value on top of chance quality. The stand-outs:

Messi tops yet another finishing table. His shot-placement-to-chance ratio is 1.29, meaning his finishing adds 29 % to the conversion probability of every shot compared with the average player in the same positions. World-class—as if you needed reminding.

Close behind is Heung-min Son at 1.25 (+25 %). Yes, Spurs really did have a world-class finisher—and that isn’t even Harry Kane. (Though Kane still makes the list at No. 8 with +10 %.)

After those two, the gap widens:

• Memphis Depay closes out the top three at +17 %—proof that a Premier-League-only lens can miss La Liga/Ligue 1 excellence (I mean he did flop at United).

• Paulo Dybala (+14%), Iago Aspas (+12%), and Ciro Immobile (+12%) complete the top six. I knew Immobile was banging in goals in Serie A, but come on — ranking him (and Aspas, another Premier League flop) among the most efficient shooters? I wouldn’t have guessed that.

• Only then do we see the usual suspects: Luis Suárez and Harry Kane (both +10 %).

• Serge Gnabry also posts +10 %, while Jonathan David from Lille adds +8 %. (Sneaky good—how hadn’t I noticed him sooner?)

Value added per shot

Another way to look at this is through the value added per shot. The table below presents the average xGOT per shot, the average xG per shot, and the absolute difference between the two.

Looking at xGOT − xG per shot highlights who squeezes the most extra value out of each and every attempt.

Messi’s average chance is already 13%, but his placement bumps it up to 17% — a 4-point boost per shot. Put differently, the best shooter in the world adds just 4 percentage points per attempt. Talk about fine margins. Of course, once you add up multiple shots, the difference becomes more noticeable.

Son adds 3 points; Memphis, Aspas, and Immobile sit around 2.

Okay, so now that we’ve covered the best shooters, let’s take a look at the underperformers.

3 — The ‘underperformers’

At the opposite end of the spectrum, 18 of the 38 high-volume scorers posted an xGOT-to-xG ratio below 1.00.

The ten lowest (who still scored more than 80 goals) appear in the table below.

Lautaro Martínez tops the list with an xGOT:xG ratio of 0.86. In other words, compared with an average player shooting from the same locations, his finishing reduces the likelihood of a goal by about 14 %.

How can that be, given his reputation as one of the world’s best strikers?

First, note that Martínez still out-scores raw xG and xGOT: he has 115 goals from 110 xG (a figure that includes team supply, movement and shot volume but still). He beats his 96 xGOT (115 goals), so something beyond sheer shot placement is helping him.

Why, then, does his xGOT/xG lag? Three plausible explanations:

1. Shot mix. Many of his attempts may be missing the target. Off-target shots keep their full xG but add zero to xGOT, pulling the ratio down.

2. Goalkeeping. Even when his placement is mediocre, the goalkeepers he faces may under-perform, conceding shots that average keepers would save.

3. Starting quality. He shoots frequently from close range, where xG is already high. Close-range strikes leave less room to add value through pinpoint placement—unlike, say, Messi-style curlers from distance that can boost conversion probability by double digit percentage points.

A surface-level read would label Martínez “wasteful,” but context matters.

Next comes Timo Werner, whose finishing is roughly 10 % below average—no surprise given his (bad) reputation at Chelsea and Tottenham. The same trio of factors (shot mix, goalkeeping, starting shot quality) could explain his shortfall if poor ball-striking ability does not satisfy you.

Most of the remaining group cluster around 0.95, near the overall mean of 0.97.

Again, at first glance, Karim Benzema (0.95) and Cristiano Ronaldo (0.97) might look like poor finishers (purely data-wise!).

They’re not. Thank you, Captain Obvious.

They win through where and how often they shoot, not by squeezing every last drop out of each strike: execution roughly average, shot selection elite. Blend in ageing curves—our sample spans Ronaldo’s final Madrid season and his time at Juve and Man United—and any modest xGOT surplus gets diluted.

Okay so what can we make from this?

4— Implications

1. True elite ball-strikers are unicorns

Across 5,724 players who took 360,430 shots in eight seasons, only 20 high-volume scorers—about 0.3 % of the sample—consistently added value with placement.

Even the very best (Messi) raise an average chance from roughly 13 % to just 17 %. Margins are razor-thin, which is why random variance can hide—or exaggerate—a short-term “hot streak.”

2. Placement gains disappear without volume

Because the per-shot edge is tiny, a striker needs a large sample before placement skill shows up through the noise.

Most forwards take fewer than 100 shots a season, so judging finishing quality after “a couple of matches” is wishful thinking.

3. Under-performance ≠ poor finisher

Lautaro Martínez, Benzema, and Ronaldo prove that xGOT < xG can coexist with world-class goal totals.

High-frequency shooters who find better positions—or face shaky keepers—can still beat raw xG. Shot selection, movement, and team context remain decisive.

4. Convergence creates edges

Because league-wide xG and xGOT trend toward 1 over time, temporary gaps are where analysts may strike (so to speak):

• Recruitment: Spot undervalued youngsters whose placement already outperforms xG, even if their volume is low?

• Risk management: Flag veterans riding unsustainable hot streaks before the market prices correction in?

Now let’s see who the top xGOT/xG performers were during the 2024/25 season.

5 — Top 24/25 Finishers

One last stop before we share the Python notebook: who actually topped the xGOT ÷ xG leaderboard in Europe’s big-five leagues last season?

I filtered for players with at least 10 league goals and then ranked them by the ratio of post-shot to pre-shot expected goals.

Shuto Machino comes out of nowhere (and newly promoted Holstein Kiel) to top the table with 1.43 xGOT to xG ratio. His shot-placement turned a typical 12.7 % conversion chance into roughly a 18.2 % one. Over the whole season, he added nearly 3 extra goals if we use the Shooting Goals Added (SGA) metric of xGOT − xG (the extra goals a player’s ball-striking contributed relative to an average finisher on the same shots).

Bryan Mbeumo is right behind at 1.42 xGOT to xG, with a league-best +5.2 SGA — no wonder Manchester United are googling his name.

Marcus Thuram finally gives Inter a striker who over-performs the models (sorry, Lautaro), while Strand Larsen (Wolves) validates the “one-to-watch” tag from our earlier xGOT primer.

And yes, that really is Scott McTominay sneaking into the top ten. Quite the season he’s had.

Why this matters

Across roughly one-third of Messi’s career, he adds +29 % per shot. Yet in a single season we already see ten players beating that mark. The lesson of course isn’t that Shuto Machino is a better finisher than Messi. It’s that one-year leaderboards are noisy.

Treat seasonal xGOT surpluses as flags, not verdicts, until the sample size grows.

And finally, here’s how to replicate this analysis in Python.

6 — The Python Corner

Interested in recreating the analysis? All you need is a Python session and the accompanying notebook.

If you’re brand-new to Python, the quickest on-ramp is Google Colab: open a new notebook in your browser, sign in with your Gmail account, and you’re ready to code—no local setup required.

Next, grab the notebook I used for this issue by clicking the button below. Inside, you’ll find step-by-step instructions on how to:

• pull eight seasons of Opta data from FBref with soccerdata

• wrangle it with polars

• replicate every insight we’ve just covered

Download Python Code

And there you have it—football’s shooting royalty, TL;DR style.

If this issue helped you, please pass it along!

Share

You now know how to rank elite finishers with xGOT, quantify how much they out-shoot the average striker, spot the big names who fall short, and see what eight seasons of data reveal about over- and under-performance in front of goal.

Until next week,

Martin
The Python Football Review

Welcome to The Python Football Review #006!

While reading James Tippett’s xGenius (a brilliant book, by the way) one idea kept bugging me:

Over the long term, only a handful of attackers outperform their expected goals (xG) tally—and when they do, it’s not by a lot.

Wait—what?

Aren’t elite forwards supposed to bury chances above expectation?

Fans, pundits, and highlight reels love the “clinical finisher” label whenever a hot streak pops up.

So I dug in.

I pulled every shot logged by Understat in Europe’s top-five leagues from 2014/15 through 2024/25 (that’s 11 full seasons) and asked three simple questions:

1. How many high-volume scorers genuinely beat their xG?

2. By how much?

3. What’s their average xG per shot? (Are they relying on tap-ins or scoring from outside the box?)

Join me for the answers—served, as always, in easy-to-follow steps with Python templates you can copy-paste.

Enjoy!

Quick Disclaimer

Now, before we dive in, here’s a quick disclaimer. If you haven’t read my 101 posts on xG and xGOT, you can catch up here and here. If you have, you would probably know that:

• xG measures chance creation—how good the opportunity was before the shot.

• xGOT measures shot execution—what the striker actually did with the ball after contact.

So, if you want to judge a striker’s pure finishing skill, you should really compare xGOT to xG.

However, the football world is obsessed with “strikers beating their xG,” so for this Review we’ll focus on Goals vs xG instead. That comparison isn’t meaningless—it’s still a model trained on thousands of historical shots—but it blends team supply, striker movement, and finishing into one value.

Now to the caveats … (the Python code to replicate the analysis from scratch is at the end of this piece).

1 — The Big picture

After crunching 11 seasons of data (2014/15 – 2024/25) from Europe’s top-five leagues, we end up with 498,324 shots.

Those shots produced 53,284 goals from 55,923 xG, which works out to:

• Goals ÷ xG = 0.95

• xG per shot = 0.11

So yes—over the long term goals and xG do converge, albeit with a slight under-performance relative to the model.

Subscribe now

2 — The High Scorers

Across those 11 seasons, 39 players scored 100+ goals. Below are the top ten, ordered by total goals

Highlights:

• Lewandowski leads the raw count—307 goals from 312 xG (Goals ÷ xG = 0.98). Under the pundit logic of “must beat xG,” the Pole would be labelled an ‘under-performer’. Reality check: the metric and the man simply converge. And given his monstrous goals tally, the two percentage points are roughly in line with the model.

• Kane posts the first big outlier: 272 goals from 239 xG (+13 %), hinting at a repeatable team supply, striker movement, and finishing edge.

• Messi goes one better (253 ÷ 219 xG = 1.15).

• Ronaldo sits almost bang on expectation (1.02), while Mbappé mirrors Kane at 1.13 and Salah hovers just above par at 1.03.

So, in the top six we have:

• One “under-performer” (Lewandowski)

• Two basically on par (Ronaldo, Salah)

• Three genuine over-performers (Messi, Mbappé, Kane)

Not quite the narrative you get from weekend sound-bites, right?

3 — The Outliers

Among all 39 centurions, who really tops the Goals ÷ xG chart—and by how much?

Let’s sort the list by that Goals to xG ratio and see which names pop.

Surprised? Which headline grabs you more:

• Son Heung-min perched at No. 1 (elite was a given, but this screams world-class),

• Dries Mertens sliding into second, or

• Liverpool “flop” Iago Aspas ranking as more clinical than Messi?

So we can say that 25 of 39 hundred-plus goal scorers posted a Goals ÷ xG ratio above 1.00.

• Son Heung-min leads the pack: 138 goals from 105.3 xG across 791 shots. That’s a 1.31 ratio—scoring 31 % more than an average player would from the same shots. That’s ridiculous. As in ridiculously good.

• Mertens (+22 %) and Griezmann (+20 %) round out the podium.

• Aspas and Dybala sit at +16 %, with Messi just behind on +15 %.

These are the rare finishers James Tippett had in mind: the tiny cohort who consistently bend the xG curve in their favour.

Notice how slim the margins are—outperforming by 9 % over a decade is enough to put you among the sport’s most efficient shooters (according to our initial definition, which of course is open to debate).

For everyone else, goals and xG converge exactly as the model expects.

Speaking of every else, what about the 14 players that scored 100+ goals but underperformed the xG?

4 — The ‘Underperformers’

So who sits at the other end of the scale—the lads who score plenty but should have scored more, given the chances they had?

Among the 39 centurions, 14 finished below expectation. Here are the “bottom” ten:

Highlights:

• Edin Džeko is the starkest outlier: 111 goals from 145 xG (Goals ÷ xG = 0.77). That’s a 23 % shortfall (compared to what the average player would score from the same shots)—ouch.

• Lautaro Martínez (0.96) and Aubameyang (0.94) under-shoot, but only by single-digits—well within normal noise.

• Timo Werner’s 0.91 fits the eye test from his Premier-League spell: excellent movement and supply, finishing not quite matching the volume of chances?

5 — What does it all mean?

1. Goals and xG converge over multi-season samples—even for superstars. That’s exactly what a well-trained (xG) model should do actually.

2. Short-term spikes still matter. A player running hot (Goals ≫ xG) is probably in form, but the burst may owe as much to team supply and a bit of luck as to pure finishing.

3. For true clinical skill, use xGOT − xG.

   • xG = opportunity quality.

   • xGOT = execution quality.

   • Shooting Goals Added (xGOT − xG) strips out the noise and isolates finishing talent. We’ll tackle that metric in a future deep dive.

xG isn’t about “clinicalness.”

It blends team service, striker movement, and finishing edge into a single probability.

Next time you hear “he’s so clinical—look at his goals versus xG,” reach for xGOT instead.

And finally here’s how to reproduce this analysis in Python.

6 — The Python Corner

So, how do you reproduce this analysis?

First things first. If you’re new to Python, head to Google Colab—the quickest, zero-setup route (all you need is a Gmail account). Open a new notebook and you’re ready to roll.

You can download the code I’m about to detail here:

Download Python Code

Install and import the packages

We’ll use soccerdata by Pieter Robberechts to pull Understat data and Polars for lightning-fast data wrangling.

!pip install soccerdata
import polars as pl
import soccerdata as sd

Define the study scope

Create lists for the leagues and the seasons you want to cover.

leagues = ['ENG-Premier League', 'ESP-La Liga', 'FRA-Ligue 1',
           'GER-Bundesliga', 'ITA-Serie A']

seasons = ['2014/2015', '2015/2016', '2016/2017', '2017/2018',
           '2018/2019', '2019/2020', '2020/2021', '2021/2022',
           '2022/2023', '2023/2024', '2024/2025']

Collect the shot-level data

sd.Understat and understat.read_shot_events() fetch every shot event for a given league-season pair. Eleven seasons across five leagues is roughly half a million shots, so expect the scrape to take up to an hour.

dfs_shots = []
for season in seasons:
    for league in leagues:
        understat = sd.Understat(leagues=league, seasons=season)

        df_shots = understat.read_shot_events()

        df_shots = pl.from_pandas(df_shots, include_index=True)

        df_shots = df_shots.with_columns([
            pl.lit(league).alias("league"),
            pl.lit(season).alias("season")])

        dfs_shots.append(df_shots)

Align columns and concatenate

Column sets can vary slightly from season to season, so we harmonise them before stitching everything together.

col_order_shots = []
for df in dfs_shots:
    for c in df.columns:
        if c not in col_order_shots:
            col_order_shots.append(c)

aligned_shots = []
for df in dfs_shots:
    missing = [c for c in col_order_shots if c not in df.columns]
    if missing:
        df = df.with_columns([pl.lit(None).alias(c) for c in missing])
    aligned_shots.append(df.select(col_order_shots))

shot_events = pl.concat(aligned_shots, how="vertical")

Big-picture aggregates

Total goals, total xG, shots, plus the global ratios:

(
    df_raw
    .with_columns(
        (pl.col("result") == "Goal").alias("goal"))
    .select(
        pl.col("xg").sum().alias("xg_total"),
        pl.col("goal").sum().alias("goals_total"),
        pl.col("shot_id").count().alias("shots_total"))
    .with_columns(
(pl.col("goals_total")/pl.col("xg_total")).alias("goals_to_xg"),        (pl.col("xg_total")/pl.col("shots_total")).alias("xg_per_shot"))

)

Player-level summary

Aggregate by player and compute Goals ÷ xG and xG per shot.

df_shots = (
    shot_events
    .with_columns(
        (pl.col("result") == "Goal").alias("goal"))
    .group_by(["player"])
    .agg(
        pl.col("xg").sum().alias("xg_total"),
        pl.col("goal").sum().alias("goals_total"),
        pl.col("shot_id").count().alias("shots_total"))
    .with_columns(
      (pl.col("goals_total")/pl.col("xg_total")).alias("goals_to_xg"),
      (pl.col("xg_total")/pl.col("shots_total")).alias("xg_per_shot"))
)

Slice the interesting bits

Top scorers (≥ 100 goals):

(
    df_shots
    .filter(pl.col("goals_total") > 100)
    .sort("goals_total", descending=True)
    .head(10)
)

Best Goal ÷ xG ratios among those centurions:

(
    df_shots
    .filter(pl.col("goals_total") > 100)
    .sort("goals_to_xg", descending=True)
    .head(10)
)

Worst Goal ÷ xG ratios among those centurions:

(
    df_shots
    .filter(pl.col("goals_total") > 100)
    .sort("goals_to_xg")
    .head(10)
)

Boom—that’s the myth of the “clinical” striker, reproduced in your own notebook.

If you found this issue useful, please share it!

Share

You now know why even world-class forwards don’t always beat their xG, why that doesn’t make them wasteful, and what 11 seasons of data reveal about true finishing outliers.

Until next week,

Martin

The Python Football Review

Welcome to The Python Football Review #005!

Today we add two more creativity metrics to our analyst’s tool belt: xGChain and xGBuildup.

By the end of this issue you’ll know

• what each metric measures

• which gap they fill (left by xA and xAG)

• which deep-lying playmakers have posted the best build-up numbers this season

• which wing-backs top the charts for participation in attacking sequences

• how to pull xGChain and xGBuildup in Python in seconds

Enjoy!

But Martin, why do we need yet another way to judge creative talent?

So far we’ve covered:

• xAG — gives the shot’s xG to the player who plays the final pass.

• xA — assigns every completed pass a probability of eventually becoming an assist.

Both reward the player closest to goal but overlook the initiators:

• deep pivots who progress play (the Rodris and Jorginhos)

• centre-backs who split lines (the John Stones and Virgil van Dijks)

• wing-backs who join the build-up (the Cafus and Kyle Walkers)

Because these actions start far from goal, they accrue only modest xA and almost no xAG.

That’s the gap xGChain and xGBuildup are designed to close.

1 — What are xGChain and xGBuildup?

xGChain gives every player who touches the ball in a possession the shot’s xG if that possession ends in a shot.

Example: a move ends with a 0.25-xG shot. Every participant—keeper to striker—adds 0.25 to their xGChain total.

Three details matter:

1. The simplest touch and a forty-yard carry count the same if they’re in the same chain.

2. No shot → 0 xGChain for everyone in that possession.

3. Because credit is copied to each player, the squad’s summed xGChain will exceed the team’s match xG—so this is a player metric, not a team one (even though we can use it to analyse team structure, more on that below).

Great for spotting who helps attacks reach the box: xAG credits one passer; xGChain credits everyone involved.

Why xGBuildup then?

Rank players by xGChain and advanced attackers still top the list—they finish and assist, so they appear in nearly every chain. To surface the early-phase contributors we use xGBuildup:

• Start with xGChain.

• Exclude the players who made the final two touches—the key pass and the shot.

What remains is xGBuildup.

Some elite attackers still rank highly even after you strip away their shots and assists; that simply means they also contribute in the build-up—valuable context.

And yes, expect Lionel Messi to still pop up near the top (not that you needed yet another metric to remind you of this).

Okay, moving on…

2 — How analysts use xGChain & xGBuildup

There are two main applications:

1. Scouting and player evaluation – surfacing deep-lying contributors who rarely appear on assist charts.

2. Tactical profiling – mapping where a team’s build-up flows without watching a single minute of video.

Below are quick case studies from the 2024/25 season (Europe’s top five leagues). You’ll be able to reproduce the tables in Python later.

2.1 — Scouting & evaluating players

Top xGBuildup/90, 2024-25

Okay, so who were the players that topped the xGBuildup per 90 minutes rankings during the past season? Because xGBuildup strips out shots and key passes, the leaderboard is dominated by midfielders and defenders—exactly the roles we want to judge.

• Vitinha sits miles clear at 1.18 xGBuildup/90—on average he takes part in attacking sequences worth 1.18 xG every match.

• His midfield partner Fabián Ruiz follows at 0.97, underlining PSG’s central dominance.

• Two full-backs—Nuno Mendes (0.91) and Achraf Hakimi (0.89)—both rank in the top four, suggesting PSG’s build-up is well balanced across flanks.

• As expected, the list is almost entirely midfielders and defenders once key-pass credit is removed.

Top xGChain/90, 2024-25

Including the shot and assist brings attackers back into view.

• Ousmane Dembélé tops the table at 1.65 xGChain/90—fitting for a player who re-invented the false-9 role in PSG’s historic season. No wonder he is now a Ballon d’Or favourite (hands up if you predicted that last August; I certainly didn’t).

• Gonçalo Ramos makes the list despite limited starts; his touches keep showing up in scoring moves even when he isn’t the one shooting.

• Bradley Barcola and Khvicha Kvaratskhelia round out the top four, underlining just how balanced PSG’s attack (and, as we saw earlier, their build-up) has been.

2.2 — Assessing team patterns

But Martin, didn’t you say xGChain and xGBuildup are player metrics?

I did—yet comparing a few key players can still reveal where a team’s build-up flows.

Earlier we saw Achraf Hakimi (right) and Nuno Mendes (left) posting almost identical xGBuildup figures, suggesting PSG advance play down both flanks in roughly equal measure. Let’s apply the same lens to Arsenal.

Arsenal wide balance, 2024-25

This season Gabriel Martinelli often looked isolated on the left. The numbers agree.

Saka is involved earlier and more often (0.31 vs 0.17 xGBuildup/90), pointing to a right-heavy build-up bias. The narrower gap in xGChain (0.84 vs 0.66 xGChain/90) shows Martinelli does contribute more in the final phases, but the attack tilts right from start to finish.

Arsenal centre-backs

Saliba and Gabriel drive progression from the back. When Jakub Kiwior steps in, Arsenal lose roughly 0.13 xGBuildup per 90 at centre-back—a reminder that depth matters if your system relies on ball-playing defenders to start attacks.

2.3 — Things to watch out for

• Team style inflation – Possession-heavy sides naturally inflate xGBuildup (I am looking at you, Pep); always benchmark within league and pace context.

• Direct teams – A low xGBuildup doesn’t always mean a player is conservative; the ball might bypass midfield altogether (think Leicester’s title-winning 15/16 campaign).

• Double counting – Forwards with huge shot volumes can dominate xGChain leaderboards. Subtract the player’s own xG if you want non-shooting influence.

• Sample size – Use per-90 numbers and set a sensible minutes threshold (e.g., >900 mins) to avoid noise.

Great, now that we have covered those, let’s do some coding.

3—How to Fetch xGChain and xGBuildup Data Using Python

Here’s how to pull xGChain and xGBuildup yourself.

If you’re new to Python, the quickest route is Google Colab—a free, browser-based notebook that needs zero local setup.

1. Go to https://colab.research.google.com and sign in with your Google account.

2. In Colab, click File → New notebook.

You can paste the snippets below or download the full notebook:

Download Python code

We’ll use two libraries:

• soccerdata, a community wrapper by Pieter Robberechts that scrapes Understat.

• polars, our preferred dataframe engine.

In the example below we pull Europe’s top-five leagues for the 2024/25 season. You can add any season from 2014/15 onward by extending the list.

Next we run a simple read_player_stats() to pull the player stats for the season and then transform the resulting pandas dataframe into a polars one with from_polars.

At this point you’ll see a wide table with dozens of columns—one row per player × season.

Next, we’ll keep only the variables we care about—season, team, player, position, minutes played, and their xGBuildup and xGChain values—and then calculate the corresponding per-90 figures.

Next, we replicate the tables from the case studies. First, we filter for players who have appeared in at least 10 matches and return the top ten in xGBuildup per 90 minutes.

And here we simply change the sorting parameter to xg_chain_90 to order the players by that metric.

And here’s the coding bit for focusing only on Saka and Martinelli

And the bit for focusing on Arsenal’s three central defenders.

You can now fire up Python and explore other seasons, teams, and players to see what the underlying data reveals.

Boom—that was xGChain/xGBuildup 101.

If you found this issue useful, please spread the word!

You now know more about these two metrics than most football fans: what they measure, how to use them, why they shouldn’t be underestimated, and—crucially—how to pull extensive data with just a few lines of Python.

Until next week,

Martin

The Python Football Review

Welcome to The Python Football Review #004!

We previously dissected Expected Assisted Goals (xAG). If you missed that issue, catch up here.

Today we explore its first cousin Expected Assists (xA)—and, spoiler alert, they are not the same metric.

By the end of this issue, you’ll know:

• what xA stands for

• how it patches two of xAG’s biggest blind spots

• how analysts use it—and the traps you should avoid

• how to profile different types of creators

• how to scrape full seasons of xA with just a few lines of Python (templates included)

Enjoy!

Wait… aren’t xA and xAG the same thing?

Be honest. How many of you thought they were interchangeable? ✋

I certainly did.

Turns out I was wrong.

Both stats aim to value creativity, but under the hood they are somewhat distant relatives.

Quick refresher on xAG

xAG assigns the xG of the next shot to the passer who supplied that shot.

• Blind spot #1 – The dribble tax: if the receiver slaloms past five defenders before shooting, the original passer still gets credit for the inflated xG.

• Blind spot #2 – The pass‑before‑the‑pass: if the receiver decides to pass rather than shoot, the original passer receives zero credit.

xA removes both blind spots:

• Freeze‑frame at reception – The passer is scored the moment the ball arrives, before any solo heroics inflate xG (looking at you, Leo Messi).

• Every completed pass counts – Even if no shot follows, each pass receives a probability of becoming a goal.

But let’s not get ahead of ourselves.

Subscribe now

1 — So What is xA?

Every completed pass is graded from 0.00 to 1.00 according to how often historically similar passes became goals.

For example, a diagonal through‑ball completed inside the box might score 0.25 xA—meaning one in four similar passes historically became goals.

Miss the receiver entirely? xA = 0. You can’t assist phantom team‑mates.

Thank you, Captain Obvious.

What goes into the model?

1. Pass context

   • Start & end coordinates

   • Pass length & angle

   • Delivery type (through‑ball, cross, set‑piece, header…)

   • Phase of play (open play, free‑kick, corner…)

2. Historical outcome

   • Frequency with which those passes became official assists

Most providers run a logistic regression (or gradient‑boosted tree) to spit out the probability.

Important: xA stops counting at reception. The receiver can pass backwards or dribble sideways; the passer already has his probability.

xA therefore does not tell you how many assists a player should have. Instead it measures the quality and frequency of passes into dangerous areas.

2 — The classic analyst pitfall

Because every successful pass enters the tally, high‑possession teams will naturally pile up xA. Summing an individual’s season‑long xA and comparing it one‑for‑one with his assist total is a category error:

• xA ≠ “deserved assists”

• xA → “volume‑weighted danger injected by passes”

Always look at per‑90 or possession‑adjusted rates and compare roles, not raw totals.

And also, be mindful of how each data provider labels its statistics.

For instance, Opta data on FBref follows the definitions we’ve used here, whereas Understat calls “xA” what we’ve previously defined as xAG.

Confusing, I know.

Bottom line: always read a provider’s documentation before using any metric.

3 — How professionals use xA

• Scouting hidden creators — Deep‑lying playmakers, wing‑backs, even centre‑backs with a quarterback switch can rack up xA long before they register a headline‑making assist.

• Process vs outcome audits — A winger on a cold assist streak but steady xA is probably getting let down by finishing, not suddenly running out of ideas.

• Tactical fingerprints — Plotting xA by pitch zone highlights which channels a team repeatedly exploits.

Most importantly, xA is often paired with xAG to refine the profile of a creator. A few rules of thumb:

• High xA + high xAG → elite creator who delivers plenty of dangerous final balls.

• High xA, low xAG → volume distributor whose team‑mates often fail to shoot.

• Low xA, high xAG → low‑touch playmaker who saves his bullets for killer passes.

Mini‑case study: the Premier League’s top 10 creators

Below are the top 10 Premier League creators for the 2024/25 season (data up to 6 May 2025). For each player you’ll see total assists, xAG, xA, minutes played, their per‑90 versions, and their ranks in terms of xA_90 and xAG_90. Data is sorted by the players’ xA_90 rank.

Don’t worry—full Python code to reproduce this table appears at the end.

So what do we see?

1. Bukayo Saka (High xA + High xAG): Arsenal’s right‑sider is both busy and deadly. He supplies lots of balls into danger (highest xA) and those balls turn into big‑value shots (xAG ≈ xA). Classic elite creator.

2. Kevin De Bruyne (Low‑volume sniper): xAG / 90 is actually higher than his xA / 90. He doesn’t spam passes; instead he waits for the killer ball that becomes a huge chance.

3. Sávio (Balanced creator): Very active and the shot value is almost keeping up with the volume. A reliable supply line for City.

4. James Maddison (High xA, low xAG): ****Maddison keeps finding advanced receivers, but Spurs either (a) take extra touches/dribbles before shooting or (b) fail to shoot at all. The pass is dangerous in principle, but the resulting shot—if any—carries far less xG.

5. Dwight McNeil (Above‑average both): ****Everton’s wide creator is fairly balanced; shot quality lags volume a bit but not dramatically.

6. Trent Alexander‑Arnold (Volume distributor): ****Lots of probing passes (high xA), yet Liverpool’s eventual shots from those balls are middling. Typical of a high‑crossing full‑back.

7. Phil Foden (Volume distributor): Similar story to Trent, although from more central zones. A steady stream of chances that aren’t always huge.

8. Martin Ødegaard (Table‑setting 10): Like Maddison, he racks up danger in the build‑up, but Arsenal often recycle or shoot from trickier angles afterward, deflating xAG.

9. Harvey Barnes (Secondary creator): ****Respectable volume; the shot value lags—perhaps because many of his passes are squared across the box rather than cut‑backs.

10. Cole Palmer (Selective killer passes): ****The inverse of Maddison/Ødegaard: Palmer’s passes don’t flood the box (xA rank only 10th), yet when he does supply a key ball it tends to become a high‑xG shot (ranked 7th). Chelsea lean on him for the decisive action rather than general ball circulation.

Phew! I hope I haven’t lost you.

The xA / xAG combination quickly highlights under‑achievers (hello, James Maddison) and selective assassins like De Bruyne or Palmer—though you probably knew that already.

Key takeaways:

• xA / xAG adds the nuance needed to spot under‑achievers.

• It can help you track how a player’s creative profile evolves over time.

• Most importantly, by applying the same analysis to less‑watched leagues and players, you can uncover the next global megastar. You’re welcome. 😊

And finally here’s the Python template of the day.

4 — Getting xA Data with Python

So how do we get our hands on xA data? If you’ve followed previous issues of The Python Football Review, you know the drill: Opta data freely shared on FBref.

Rather than spend hours writing your own scraper, let Pieter Robberechts’ soccerdata library handle the heavy lifting.

Before we begin, here’s a download link to the code you are about to read.

Download code

So first we install soccerdata and import it alongside Polars.

Next we define the scope of our study by specifying the 2024/25 English Premier League season from FBref. We fetch the passing stats by calling read_player_season_stats with stat_type="passing" to capture both xA and xAG.

The returned DataFrame has 28 columns.

That’s why we keep only what you need—player, position, 90s, assists, xAG, and xA—then convert it to Polars for easier wrangling.

And finally we wrangle the data to

• Filter out players with fewer than 10 matches.

• Create the per‑90 metrics.

• Rank xA_90 and xAG_90.

• Sort by xA_90 in descending order.

Et voilà—the table you just saw, ready for analysis.

Boom—that’s xA 101.

If you found this issue useful, please spread the word! You now know what xA is, how it’s calculated, why so many people confuse it with xAG (and why you won’t), how to uncover hidden creative talent, and—most importantly—how to pull a season’s worth of data with just a few lines of Python.

I’m still experimenting with the newsletter’s format, so your feedback is invaluable. Would you prefer shorter bites, longer deep dives, more Python, or more case-studies? Or does this mix hit the sweet spot?

My goal is to build this newsletter with you.

Until next week,

Martin

The Python Football Review

Welcome to The Python Football Review #003!

We’ve already dissected xG (chance creation) and xGOT (shot execution).

Today we slide one pass earlier in the move: Expected Assisted Goals (xAG).

By the end of this issue, you’ll know:

• what xAG measures

• the biggest blindspots to watch for

• how it differs from expected assists (yes they are different)

• how professionals uncover hidden creative talent using it

• how to pull 8 seasons of xAG data with a few lines of Python code (templates included)

Enjoy!

First things first… “Aren’t assists good enough?”

Raw assists matter, but they’re messy:

• Finisher‑dependent: A defence‑splitting through‑ball earns zero credit if the striker skies it.

• Team‑dependent: Creators at goal‑rich clubs stack assists; equally gifted players on low‑scoring sides look anonymous.

Analysts needed a way to rate the quality of the pass itself, independent of who finishes—or whether anyone finishes at all.

Enter Expected Assisted Goals (xAG).

1 — What is xAG?

Think of xAG as xG but for the passer.

xAG equals the xG of the shot that immediately follows a completed pass.

So it’s a probability between 0 and 1 that the shot resulting from the pass would transform into a goal.

• 0.00 → a pass that virtually never leads to a goal

• 1.00 → a pass that would become an assist for a goal every single time

Add up every pass’s xAG and you get how many assists a player should have given the quality of chances he supplies—regardless of finishing luck.

In short, xAG adds quality to the raw quantity of passes leading to shots.

It removes finishing noise and levels the field across teams, turning raw pass counts into a continuous, chance‑quality metric.

Subscribe now

2 —xAG blind spots

No stat is perfect—xAG included. Two common traps you should be aware of:

1. The Messi Dribble Tax

   A five‑yard square ball to Messi in the middle of the pitch that he turns into a wonder‑goal by dancing his way through 5 defenders still hands the passer the full xAG. Great for Busquets’ résumé; not great for isolating creative genius.

2. The Pre‑assist Disappearing Act

   A deep-lying Pirlo laser that breaks the press, followed by one extra square pass of the receiver, earns 0 xAG for Pirlo. The metric only credits the final ball before the shot.

Now there are other metrics such as xA (expected assists) and xT (expected threat) that can plug those gaps—but that’s a story for another issue.

Bottom line: use xAG, but never in isolation. It captures far more nuance than raw assists, yet still needs context from video, xA, or xT to tell the full creative story.

“But Martin, isn’t xAG just expected assists—xA?”

If only it were that simple, my friend. The two are related but not the same:

• xAG gives the passer the xG of the very next shot. No shot, no xAG.

• xA values every completed pass, shot or no shot, so long as it historically leads to goals often enough.

xA fixes the “no‑shot, no credit” problem—but in doing so it introduces its own quirks (a story for another newsletter).

For now, just remember: xAG and xA measure the same creative impulse from two different angles. Don’t mix them up.

All right—so how do the pros actually use xAG?

3 — How professionals use xAG

Just as xG separates luck from finishing skill, xAG tells a richer story than raw assists ever can.

By rewarding pass quality, it has become the go‑to metric for judging creative players—especially midfielders whose reputations hinge on the final ball.

Rating creators over time

Over large samples xAG drifts toward a player’s assist total, but the gap between the two is where the insight hides:

A simple roll‑up therefore is Assists − xAG.

• Negative across a season? Bad luck or blunt finishing.

• Positive? Visionary passer or ruthless finishers.

Let’s do a mini case study and uncover Europe’s top under‑credited architects.

Who’s been most let down by team‑mates since 2017‑18?

Here are the top five “should‑have” creators as of 2 May 2025 (you will get to replicate this analysis with our templates below):

Serge Gnabry’s Bayern teammates hardly lack fire‑power, yet he “deserved” roughly 12 more assists (-11.9 xGA) on top of his 33 from 191 games. Further down we find creators at less glamorous clubs—Lorenzo Pellegrini (Roma) with -11.8 xGA, Junya Ito (Reims) with -11.4 xGA, Jesus Navas (Sevilla) with -11.2 xGA—whose teammates squandered double‑digit chances.

Sort by Assists-xGA per 90 minutes and hidden gems pop even faster (if you can define a player playing for Europe’s top 5 leagues as “hidden”).

• Remi Oudin (Lecce) −0.17 Assists–minus-xAG per 90 minutes ≈ 7 “missing” assists per season (that’s 0.17x38)

• Lucas Pérez (Deportivo La Coruna) ≈ 6 “missing” assists

• Angelo Fulgini (Lens) ≈ 6 “missing” assists

Of course, those players hardly unknown—each plays in a top league—but the exercise shows how quickly a global database can surface creators whose numbers lag behind their service.

And that’s exactly what recruitment departments do. Filter your database for high  xAG/90, low Assists/90. Swap their wasteful strikers for clinical finishers and the numbers explode.

Hot‑streak beneficiaries

Now for the over‑performers—usually stars on elite, clinical sides.

Top of the pile is Thomas Müller: Bayern’s finishers converted 25.8 more goals than his xAG implied. He’s followed by a surprise name, Paul Pogba (+16.4), then Jadon Sancho in his Dortmund days (+14.9), Florian Wirtz (+13.7) and Mohamed Salah (+13.3).

So to recap, xAG lets clubs spot two very different stories:

1. Underrated creators—high xAG, few assists—who might explode with better finishers.

2. Hot‑streak beneficiaries—assists far above xAG—whose numbers could cool when the shooting luck fades (or if paired with less skillful finishers).

And finally, here’s how to get 8 seasons of data with a few lines of Python code.

4 — Getting xAG data in Python

If you’ve been reading The Python Football Review for a while, you know the drill: Opta’s advanced data—shared free on FBref—is the easiest starting point.

Rather than scraping it by hand, we’ll lean on Pieter Robberechts’ (@p_robberechts) community wrapper soccerdata and wrangle the results with polars.

Before we begin, here’s a download link to the code you are about to read.

Download Code

To start coding, just go to Google Colab (zero setup—just your Gmail) and open a new notebook. You can either import the code (that you just downloaded), or type it yourself by following the instructions you are about to read.

So the first thing you’ll need to do is to install soccerdata, then import it alongside polars (for data wrangling).

Next, define your study window with sd.FBref. For this demo we’ll pull the last eight seasons across Europe’s top‑five leagues.

Next we call read_player_season_stats(stat_type="standard")

The raw DataFrame arrives with 33 columns; we keep only the essentials—position, matches, minutes, assists, and xAG—rename them for sanity, and convert to Polars.

Et voilà—we now have our clean analysis-ready data.

We continue the analysis by grouping by league / team / player, aggregating totals, and creating our key metrics:

• Assists − xAG

• Assists − xAG  per  90 minutes

Sort ascending Assists − xAG to spot under‑credited creators.

Add a minimum‑xAG filter (e.g., ≥ 5) to avoid tiny‑sample noise and sort ascending Assists − xAG  per 90 minutes to spot under‑credited creators.

Sort descending Assists − xAG to see who’s thriving on clinical team‑mates.

Within minutes you’re staring at clean tables showing who deserved more assists and who benefited from red‑hot finishers.

Boom—that’s xAG 101.

If you found this issue useful, please spread the word! You now know more about xAG than most football fans: what it measures, how professionals use it, why it isn’t the same as xA, and—crucially—how to pull eight seasons of data with a handful of Python lines.

I’m still experimenting with the format of the newsletter, so your feedback is super welcome—would you prefer shorter content, longer deep dives, more Python, or more football concepts? Or does this format hit the mark?

My aim is to build a truly practical newsletter together with you.

Until next week,

Martin

The Python Football Review

Welcome to The Python Football Review #002!

We previously broke down xG (missed it? grab it here).

Today we move one step closer to goal: Expected Goals on Target (xGOT).

By the end of this issue, you’ll know:

• what xGOT really measures

• how it patches xG’s two biggest blind spots

• the two ways analysts rely on it (and why we should talk about Strand Larsen and Emiliano Martinez more)

• how to pull seasons of xGOT with just a few lines of Python (templates included)

Enjoy!

First things first… but Martin didn’t you say xG is already the best forward-looking metric we’ve got?

First, it was the data providers who said it.

And second, xG is indeed brilliant at describing chance creation, but it freezes the play before the ball leaves the boot.

xGOT presses “play” and tells us what happened after the strike.

And that small difference unlocks a lot.

1 — Why xG needed an upgrade

Even xG die-hards admit two stubborn flaws:

Enter xGOT.

A more skillful striker will typically post a higher xGOT—striking the ball cleaner, placing it smarter, and adding extra pace or spin. In short, xGOT bakes a slice of execution skill into the goal probability, neatly answering both critiques.

Let’s define xGOT and then explore how professionals use it.

2 — So, what is xGOT?

Expected Goals on Target looks only at on-target attempts.

It begins with the shot’s original xG, then layers on post-contact detail:

• precise landing spot in the goal frame

• height, velocity, even spin

A postage-stamp rocket earns more credit than a daisy-cutter straight at the keeper.

In short, xGOT answers:

“Given how this ball was struck and where it finished, how often does a keeper still save it?”

Declan Rice’s second goal vs Real Madrid — textbook example

Same attempt, two very different tales: the chance was mediocre, the strike was elite.

An xGOT of 0.97 means that if a player executed that exact strike 100 times—same speed, placement, and technique—97 would find the net, and the keeper would save only three of those attempts.

Miss the target or get your shot blocked? xGOT = 0. After all, you can’t score what you don’t put on frame.

A key takeaway is that—just as with xG—over large samples xGOT and actual goals converge.

That means you can choose a time window (a month, half-season, full campaign) and measure how much a team or player over- or under-performed during that span.

(Note that depending on the data provider, xGOT may also be called post-shot expected goals (PSxG) so be prepared).

Subscribe now

3 — Two ways professionals use xGOT

Quantifying finishing quality

Beginners often judge a striker by Goals vs. xG. That’s a start, but xG bundles two separate things:

1. Getting into position – the runs, passes, and off-ball movement that create the chance

2. Estimating the shot’s chance to become a goal – without ever measuring how the ball was struck

So Goals-minus-xG mixes chance creation and finishing outcomes, while overlooking the crucial nuance of execution (placement, power, spin).

To isolate pure finishing skill, compare xGOT to xG instead:

A handy summary metric you may encounter is Shooting Goals Added (SGA), which is simply SGA = xGOT − xG

• High SGA? A scout’s eyebrow should rise.

• Low or negative? Either poor technique or a cold streak—check the sample size before you draw conclusions.

This means that if a striker racks up 20 xGOT in a season while registering 15 xG, his Shooting Goals Added would be: 20  −  15  =  +5. In other words, his finishing skill would be expected to deliver five extra goals above expectation for his team over that period.

“We need to talk more about Strand Larsen”

Okay, let’s do a mini–case study. A couple of weeks ago, BBC Sport argued we should be talking more about Strand Larsen at Wolves.

Wait, Strand who?

Let’s see what SGA = xGOT−xG reveals about that striker—even if this is the first you’ve heard of him.

As of May 2 (when I’m writing), here are the top six Premier League non-penalty goal scorers. Salah, Haaland, Isak. Nothing surprising here.

Now, here are the top six players by SGA = xGOT − xG.

Mo Salah still leads with +6.91 SGA—he has scored nearly seven extra goals purely through his finishing skill. Next comes Chris Wood (+6.02), then Bryan Mbeumo (+5.53).

And then there’s Strand Larsen, climbing into fifth with +4.23 SGA.

SGA offers a fresh lens. For established names like Salah or Haaland, it confirms what we already suspected. But Larsen’s place in the top five shows the Wolves hype has real merit.

I’m not claiming xGOT—or SGA—is flawless. Strikers contribute more than goals alone. But when it comes to pure shot execution, it adds the nuance we’ve been missing.

Maybe it is indeed time to talk about Strand Larsen xGOT more.

Moving on…

Assessing shot-stopping

The second major use of xGOT is to assess the shot-stopping quality of goalkeepers.

The logic is straightforward:

• if a keeper concedes more goals than xGOT would predict, he’s underperforming;

• if he concedes fewer, he’s exceeding expectations.

So for keepers we flip the script and talk about Goals Prevented = xGOT conceded − Goals conceded

Please note an important nuance:

• For strikers, we compare xGOT to xG—that is, we measure how well the striker struck the ball versus the average shot from that position.

• For goalkeepers, we compare xGOT conceded to goals conceded—that is, we assess, given the difficulty of the on-target shots they faced, whether keepers saved or allowed them.

Calculation note: When comparing xGOT conceded to goals conceded, data providers typically drop own goals, since no xGOT value can be assigned to a strike that was unintended for the target.

This means that if a keeper conceded 40 goals in a season—4 of which were own goals—while facing 38 xGOT, then his Goals Prevented would be: 38  −  (40−4)  =  +2. In other words, his shot-stopping skill saved an extra 2 goals for his team over that period.

“Emiliano Martinez is not a great goalkeeper”

Okay, let’s do another mini–case study. Emiliano Martínez often draws criticism—mainly for his outspoken personality (just remember that World Cup celebration).

Pundits routinely question his quality—”he’s a good goalkeeper, just not a great goalkeeper”. So, what does xGOT reveal?

Since 2019/20 (through May 2, as I write), Martínez has racked up +10.5 Goals Prevented (that’s 233.5 xGOT faced – 223 goals conceded as per Opta via Fbref), which works out to +0.09 Goals Prevented per 90 minutes per season. Over a 38-game season, that’s +3.42 goals saved.

How does he compare to (the great) title-winning peers?

• Ederson: +4.1 Goals Prevented (165.1 xGOT – 161 goals), or +0.03 per 90 → +1.14 per 38 games

• Alisson: +12.1 Goals Prevented (178.1 xGOT – 166 goals), or +0.05 per 90 → +1.90 per 38 games

Martínez’s +3.42 dwarfs Ederson’s +1.14 and edges out Alisson’s +1.90.

See why analysts rave about him now?

I’m not claiming xGOT is the sole arbiter of goalkeeping greatness—there’s distribution, command of the area, and so on—but in pure shot-stopping terms, Martínez ranks among—and arguably leads—the Premier League (over the last six seasons).

And finally here’s the easiest way to get xGOT data with Python.

4 — Getting xGOT data in Python

The easiest free route—no custom scraping, no manual copy-pasting, no pricey API key—is the soccerdata wrapper by Pieter Robberechts (@p_robberechts). In just a couple of lines, you’ll be swimming in post-shot metrics from Opta (called PSxG on FBref).

First, if you’re on Google Colab (the fastest way to start Python with zero setup), install and import soccerdata.

Then define your study parameters—for example, Premier League, 2024–25—and call read_schedule() to fetch that season’s fixture list.

Once you have the schedule, extract the game_id column into a list and pass it to read_shot_events().

The result is a pandas DataFrame where each row is a shot event: minute, player, xG, PSxG (xGOT), outcome (goal/off-target/saved/blocked), distance, body part, plus the two players who combined to create the chance.

With eight lines of code you’ve built a detailed shot log. Note: pulling one game’s worth of shots takes about 7 seconds—so a full 380-game season is roughly 45 minutes.

For goalkeeper analysis, run a similar call to read_player_match_stats(stat_type="keeper").

You’ll get one row per keeper per match, with fields like saves, goals conceded, PSxG (xGOT) faced, and more—ready for your shot-stopping deep dive.

I did tell you it was going to be easy, didn’t I? 😊

Here’s a link to the code if you want to copy-and-paste it.

Download Python Code

Key takeaways

• xG explains chance creation; xGOT shows what the shooter did with it.

• For strikers: xGOT vs. xG → finishing talent.

• For goalkeepers: xGOT conceded vs. Goals conceded → shot-stopping grade.

Boom—that’s xGOT 101.

If you found this newsletter helpful, please spread the word! You now know how xGOT is calculated, what it measures, why it matters, the two ways professional analysts use it, and how to grab xGOT data in seconds.

I’m still experimenting with the format of the newsletter, so your feedback is super welcome—would you prefer shorter content, longer deep dives, more Python, or more football concepts? Or does this format hit the mark?

My aim is to build a truly practical newsletter together with you.

Until next week,

Martin

The Python Football Review

P.S. If you enjoyed this newsletter and want to support it (I spend around 8 hours writing these), please share it on Twitter or LinkedIn. I know it can feel like a chore—trust me, I often hesitate too—so to say thanks I’ll send you an extended Python notebook that automatically pulls eight seasons of xGOT data (shots and goalkeeper metrics) from Europe’s top five leagues, fully wrangled into one analysis-ready dataset. Just send me an email (martin@pythonfootball.com) once you’ve shared, and I’ll send it over. Cheers!

Welcome to The Python Football Review #001! 🎉

We’re kicking off with the stat that rewired football analysis—Expected Goals (xG). It’s quoted on broadcasts, splashed across Twitter infographics, and still sparks arguments every weekend.

By the end of this issue, you’ll know:

• What xG really measures (and what it doesn’t)

• The one misconception that trips up even seasoned pros

• Why xG is a game‑changer—and why its loudest critics are (mostly) wrong. Looking at you, Jamie Redknapp.

• How to pull xG data with a handful of Python lines (templates included)

Enjoy!

1 — So, What Is an Expected Goal?

Put simply, an expected goal (xG) is a value between 0 and 1 that measures how likely a shot is to become a goal. For example:

• A long-range screamer might be 0.01 xG (1% chance).

• A tap-in could be 0.92 xG (92% chance).

Or more formally, xG quantifies the probability of a shot converting into a goal before the ball is struck.

That last piece is crucial: xG is fundamentally a pre-shot probability, not strictly a finishing metric. It’s a chance-creation measure, capturing how effectively a player (and by extension a team) reaches dangerous zones into one distilled value.

Case in point: Remember those two screamers Declan Rice scored in the first-leg quarter-final against Real Madrid?

The second one had an xG value of 0.06. That means if an average player attempted that same free-kick 100 times from 27 yards out, only 6 would typically go in. Yet Rice nailed it.

(And don’t get me started on the fact that he’d taken just 9 free kick shots in his entire professional career before attempting those two against the reigning European champions.)

That’s the power—and fun—of xG. It highlights when something is truly out of the ordinary.

But Martin, how do we actually decide it’s 6%, not 5% or 4%?

Glad you asked! xG providers (like Opta or StatsBomb) analyze hundreds of thousands of historical shots with similar conditions—distance to goal, angle, body part, defensive pressure, pass type leading to the occasion, position of the goalkeeper and more. Then they look at how often those shots were converted. And that’s basically it.

A few rules of thumb:

• Closer to goal → higher xG

• Wider shooting angle → lower xG

• Headers generally have lower xG than footed shots

• Penalties are worth about 0.79 xG

Different providers weigh these factors slightly differently, so you may notice small variations in xG values from one site to another (or as the famous saying goes … not all xG are created equal).

But, ultimately, xG shows how many goals an average team would be expected to score from those chances. It’s a measure of how good a shooting opportunity is, based on the historical likelihood that a similar shot ends in a goal.

Subscribe now

2 — The Big Misconception: No More Than 1 xG per Attack

So far, you’ve learned that data providers assign an xG value to each shot. But how do we get a team’s (or a player’s) total xG for a match?

But Martin, don’t we just add up all the xG?

You’d think so, but that can overshoot reality. Here’s the issue.

A team can’t score more than one goal in a single attacking sequence. Let’s say we have a striker who attempted two shots in the same attacking sequence:

• Shot #1: 0.45 xG (one-on-one with the keeper)

• Shot #2: 0.70 xG (rebound from the first shot on an open net)

If you just add them, you get 1.15, implying the possibility of more than one goal in that same possession—which is impossible.

To avoid inflated totals, data providers calculate the probability of no goal happening, then subtract that value from 1:

• In our example, the chance of not scoring would be equal to = (1 - 0.45) × (1 - 0.70) = 0.55 × 0.30 = 0.165 meaning that there is a 16.5% chance of the attack not finishing with a goal.

• And this leaves us with a 1 - 0.165 = 0.835 (83.5%) chance of the attack finishing with a goal.

Likewise, a single player can’t rack up 1.15 xG from one continuous attack. The provider caps the total at 0.835 (83.5%) for that sequence.

So, individual shots can still have 0.45 and 0.70 xG, but match stats will show the possession’s combined xG as 0.835.

Phew! I hope I did not lose you.

Long story short:

• One shot? Use its xG “as is.”

• Team or player totals? Data providers adjust to ensure no single attacking possession exceeds 1 xG.

Plenty of fans—and even some professionals—overlook this nuance. But now you know better!

3 — xG’s blind spot

Before I gush about the two ways xG changed football analytics, a quick reality check: xG isn’t perfect. It’s an aggregate measure—it doesn’t care who pulls the trigger or how the shot is struck.

xG rates the chance, not the shooter—a subtlety many people miss.

If the average conversion rate from a position is 30 %, that doesn’t mean every player finishes 30 % of the time. Gabriel Jesus might tuck them away 20 % of the time, while Erling Haaland buries 50 %.

And that’s the point: xG measures the quality of the chance, not the quality of the player on the end of it.

Still, fans and analysts love using the gap between Goals and xG as a finishing barometer. It’s handy—just easy to misread.

Remember, xG is assigned before contact. It shows how often a player gets into prime areas plus the historical finishing rate from those locations.

We’ll cover a sharper finishing metric—Expected Goals on Target (xGOT)—in a future issue. xGOT grades the strike after it leaves the boot. Until then, Goals − xG is fine—just know it blends chance quality and historical finishing.

4 — Two Reasons xG Revolutionized How We Think About Football

(a) xG Tells a Fuller Story Than Goals Alone

Goals are rare and don’t always reflect who actually controlled a match. A team might play poorly yet score a couple of lucky goals and win 2–0, while another team might dominate every aspect but fail to find the net.

xG reveals how many dangerous chances a team generated (and allowed). For instance:

• A 2–0 win with an xG scoreline of 2.5–0.7 suggests the winning side not only finished well but also likely stifled the opponent.

• A 2–0 win with an xG scoreline of 0.7–2.5 implies the hosts scored on minimal opportunities while the visitors simply couldn’t convert. Could be luck, poor finishing, or a brilliant goalkeeper.

And because xG captures this deeper performance nuance, it’s arguably (dare I say it) the most accurate predictor of future team (and player) success we currently have (according to the data providers, not just me).

But wait, Martin—doesn’t game state matter?

What if a strong attacking team scores two early goals, then sits back to protect its lead in the last 15 minutes? That scenario could let the opponents rack up a bunch of late xG, even though the attacking team stayed in control.

Exactly. That’s why nobody should rely on xG (or any other metric for that matter) in isolation. Context matters, so it’s best paired with xG match evolution graphs (which we’ll create in future newsletters) or deeper contextual analysis.

And finally, let’s not forget that defensive teams can still rack up xG: Even if you “park the bus,” you might create high-value counterattacks against fewer defenders—sometimes resulting in a surprisingly high xG.

(b) xG Separates Skill from Luck

The most common (early) critique of xG was: “If the real scoreline doesn’t match the xG, then xG is pointless!” But it’s actually the other way around: if the final score departs drastically from xG, that might indicate randomness or exceptional finishing/defending.

And that’s precisely why clubs like Brighton stuck with Graham Potter even during their disastrous (results-wise) 2020/21 season. The xG numbers showed they were creating—and conceding—chances at a level worthy of European qualification (as opposed to their actual 16th-place finish, just two spots above the relegation zone).

Over the long term, xG and actual goals tend to converge. Short-term luck—good or bad—can skew results for a while, but eventually, high-chance-creating teams rise, while those living on half-chances often slide.

And that’s exactly what happened with Brighton: by the 2022/23 season, the Seagulls finished 6th and earned a place in European football.

Over time, xG and actual goals tend to converge. A freak week, month, or even half‑season can bend the curve, but keep creating high‑value chances (and limiting the opposition) and the scoreboard will eventually fall in line.

In the long run:

• Clubs that consistently outperform xG—Manchester City, peak Liverpool—aren’t “lucky”; they own a repeatable edge the model can’t quite capture.

• Teams that habitually underperform xG are usually paying for poor finishing, shaky defending, tactical flaws, or endless managerial roulette.

Captain Obvious, at your service.

In the short run, though, you can dominate xG and still lose—and those are the matches pundits seize on to declare the stat “pointless.” Context is everything; one game is noise, a season is signal.

So, no, xG isn’t perfect, but it brings priceless nuance to any discussion of skill and luck. The problem isn’t that pundits misunderstand the metric; they misapply it.

Cue Jamie Redknapp. After Newcastle thumped Crystal Palace 5–0, he scoffed at the Magpies’ modest 1.39–2.0 xG and declared, “xG is nonsense.”

https://www.skysports.com/football/video/12606/13350226/jamie-redknapp-was-bemused-by-newcastles-low-xg-against-crystal-palace

Why the score and xG diverged

A big gap usually comes from one—or a mix—of three factors:

1. Clinical over‑performance — Freakish finishing, goalkeeper howlers, or own goals (which carry zero xG).

2. Cold under‑performance — Fluffed sitters, heroic saves, or a missed penalty (~0.79 xG down the drain).

3. Both of the above — One team red‑hot, the other ice‑cold.

Against Palace, Newcastle hit the perfect storm:

That’s three goals from just 0.08 xG.

Meanwhile Palace’s best moment—a penalty worth ~0.79 xG—clattered wide, and Newcastle’s defence swatted away two other high‑value shots.

So, Jamie, this wasn’t a straightforward 5‑0 masterclass; it was a cocktail of wonder‑strikes, an own goal, stout defending, and a blown spot‑kick. xG lays the pattern bare, even if you missed the live broadcast. 😊

Enough theory—let’s grab some data. Here’s how to download current and historical xG numbers with just a few lines of Python.

5 — How to Fetch xG Data Using Python

In this final section, you’ll learn how to download historical xG data from Understat.com using just a few lines of Python code.

If you’re completely new to Python, the easiest way to get started is with Google Colab—a free, cloud-based service that lets you write and run Python code directly in your browser, no setup required.

1. Go to https://colab.research.google.com and sign in with your Google account.

2. In the Colab dashboard, click File in the top menu, then select New notebook.

From there, you can type in the code I’m about to share, or simply download it from the link below.

Grab the Free Python Code

Now, let’s see how to get your hands on xG data. We’ll use a Python library called soccerdata (created by Pieter Robberechts), which makes collecting valuable stats quick and easy. You can learn more about it here.

First, install the soccerdata package. Then import it alongside our data-wrangling library of choice, polars❤️. Once that’s done, set your parameters. In the example below, we’re pulling xG data from the English Premier League for the current (as of writing) 2024/25 season.

Collecting Match-Level xG Data

Next, let’s move on to the actual data collection. Here’s how you can pull match-level xG information. In the snippet below, we grab data for every game in the current season, focusing on the home and away teams’ goals as well as their respective xG figures. We also convert the resulting Pandas DataFrame into a Polars DataFrame to take advantage of Polars’ exceptionally easy, plain‑English expressions. (Stay tuned for a dedicated newsletter on this topic soon.)

Collecting Player-Level Match xG

The code snippet below fetches data for each player’s xG performance on a match-by-match basis. Here, we’ve filtered the results to show Bukayo Saka. You can see that in his first match of the season against Wolves, he scored 1 goal from 5 shots, with a total xG of 0.52.

Collecting Player-Level Season xG

The following snippet retrieves each player’s cumulative xG over the entire season. In this example, we observe that, at the time of writing, Bukayo Saka has accumulated 6.18 xG across 19 matches, scoring 6 goals in total.

Collecting Player-Level Shots xG

Finally, here’s how to access shot-level data for a specific player. In the snippet below, each of Bukayo Saka’s attempts is listed with details like shot location, xG value, body part used, the situation (e.g., open play or set piece), and the outcome (goal, saved, or missed).

It goes without saying that we’re only scratching the surface of what the soccerdata package can do—you can pull tons of other advanced metrics from it. But since this newsletter is already running long, I’ll let you explore the rest on your own.

Also note that you can access data going back to the 2014/15 season for all of Europe’s top five leagues by using these keys:

• 'ENG-Premier League'

• 'ESP-La Liga'

• 'FRA-Ligue 1'

• 'GER-Bundesliga'

• 'ITA-Serie A'

Boom! And that’s it for this first edition.

If you found this newsletter helpful, please spread the word! You now know how xG is calculated, what it measures, why it matters, how to avoid the “1.15 xG in one possession” pitfall, and how to grab valuable xG data in seconds.

I’m still experimenting with the format of the newsletter, so your feedback is super welcome—would you prefer shorter content, longer deep dives, more Python, or more football concepts? Or does this format hit the mark?

My aim is to build a truly practical newsletter together with you.

Until next week,

Martin

The Python Football Review

P.S. If you enjoyed this newsletter and want to support it, please consider sharing it on Twitter or LinkedIn. I know it can feel like a chore (I usually hesitate too), so to say thanks, I’ll send you an exclusive extended Python notebook that downloads 10 seasons of xG data from Europe’s top five leagues—fully automated and wrangled into one dataset ready for analysis. Just send me an email at martin@pythonfootball.com once you’ve shared, and I’ll send it over. Cheers!