Creating a list from combinations of the original data
The main way to do this faster is to use fewer loops and to do more in each loop. (AFAICT)

loops in there...


A (for event)
A.1 (make team pairs)
A.2 (make dgen)
A.3 (for team, result in event)
A.3.1.1 (for key in pairs)
A.3.1.2 (sum)
A.4 (for pair diff)


You have a lot more flexibility if you use the for loop instead of mostly comprehensions and permutations. And, permutations is wasteful, here, (as discussed, below) because it prevents a few optimisations.

A key change is we can do A vs B and B vs A in the same pass of the loop. So, we can change our loop from "for each team go through all teams" to "for each team go through all following teams". It's a big improvement.

For the line-up A, B, C, D, our iterations look like:


AB &amp; BA
AC &amp; CA
AD &amp; DA


.


BC &amp; CB
BD &amp; DB


.


CD &amp; DC
(done)


So, the algorithm might end up something like (in pseudo code):

past_score_differences = defaultDict(float)

for each event:

    team_outcomes = defaultDict(float)

    teams_len = len(teams in event)
    for i in range(teams_len - 1):
        home_team = teams[i]
        home_score = scores[i]

        for j in range(i+1, teams_len):
            away_team = teams[j]
            away_score = scores[j]

            team_outcomes[home_team] += past_score_differences[(home_team, away_team)]
            team_outcomes[away_team] += past_score_differences[(away_team, home_team)]

            past_score_differences[(home_team, away_team)] += home_score - away_score
            past_score_differences[(away_team, home_team)] += away_score - home_score

        list_zz.append(team_outcomes[home_team])

    # the last team doesn't go through the outer loop
    list_zz.append(team_outcomes[teams[-1]])


Still a lot of loops, but far fewer and with fewer iterations for the innermost loop.

If there is a lot of consistency in the team IDs, then you might consider not using a tuple as the key but instead using a dict within a dict, e.g.

example_past_differences = {
    'A': {
        'B': 10,
        'C': 11,
        'Etc...': 99
    }
}

# later, when accessing

home_team = ...
home_score = ...
home_past_differences = past_score_differences[home_team]
for ...
    away_past_differences = past_score_differences[away_team]
    ...
    team_outcomes[home_team] += home_past_differences[away_team]
    team_outcomes[away_team] += away_past_differences[home_team]


One last thing, your variable names are not easy to understand. I made mine way too long for accesibility to understand, but generally I think the guidance in these slides is very useful: https://talks.golang.org/2014/names.slide#1