Find total points for each team's starters.

[rbhall303]

Hello,

Newbie here. I am trying keep track of our league's trades this year so, ultimately, we can make of fun of the worst trade at the end of the season. To do this, I wrote function to calculate how many starter points each player put up for a team like this:

def get_team_starters_value(league, team):
    #Initial dict for storing starter:value pairs.
    starters = {}

    #Iterate through weeks and grab box scores
    for k in range(16):
        week = k + 1
        box_scores = league.box_scores(week)

        #Iterate through each box_score until you find team
        for i in range(6):
            current_box = box_scores[i]
            #If team is home_team, add each starter points to dictionary
            if current_box.home_team == team:
                for player in current_box.home_lineup:
                    #selects starters only
                    if player.slot_position != 'BE' and player.slot_position != 'IR':
                        #create new starter and add points, or add points to if starter already exists.
                        starters[player.name] = starters.get(player.name, 0) + player.points
            #same as above, but if team is away_team
            elif current_box.away_team == team:
                for player in current_box.away_lineup:
                    if player.slot_position != 'BE' and player.slot_position != 'IR':
                        starters[player.name] = starters.get(player.name, 0) + player.points
    return starters

This function will return a dictionary with each starter's name as the key, and the total starter points as the value. My plan is to do this for each team, and store all that in a dictionary so I can then search for team-specific player values to add to my analysis. The problem is, this function takes over 30 seconds to run (using 2020 data to test), which means in a 12 team league it takes me about 7 minutes to make my master dictionary. This isn't a huge deal, since I'll probably only use it once at the end of the season, but for learning's sake, I'm wondering if anyone has a more efficient way of doing this?

[cwendt94]

One way to optimize this function would be instead of only saving players for one team, have the main dictionary key be teamId and then have the value be the starters dictionary.

This way you would only need to run through this function once and add starters and their points for every team.

[rbhall303]

Of course! Thank you for your reply!

I fixed it now, but I didn't use ID's, I just iterated through league.teams and set each team object to be the keys of the master dictionary. I may end up using ID's to be more consistent, and I'm not sure what will happen if a team changes their name over the course of the season.

BTW, your work here is amazing, thanks for keeping this project up!

[cwendt94]

Nice, that will work as well! Team IDs will always stay the same for a team even if their name changes.

No problem, it has been a lot of fun!

[joshbis]

I'm curious - how are you tracking the trade element? It can get tricky, especially in a league with a lot of deal-making where players get picked up, dropped, or traded on to other teams.

[rbhall303]

Bear in mind, I'm very to new coding generally, and python/data science specifically...

But I have just been scraping a list of all the trades using the pre-built recent_activity function, something like this:

league.recent_activity(size=200, msg_type='TRADED')

I chose 200 just to make sure I get all the trades on the season (our league doesn't even come close to that). The next thing I do feels really inelegant to me, and I'm open to ways to improve it, but essentially I wanted to create a dictionary for each trade, so I can access different elements specifically and upload them to Google Sheet, so I made this function:

def create_trades_data(trades_list):
    #empty list to store each trade dict
    trades_data = []
    
    #iterate through list of trades, oldest to newest.
    for current_activity in reversed(trades_list):
        # Store date and team data for trade
        date = datetime.date.fromtimestamp(current_activity.date / 1000.0)
        team1 = current_activity.actions[0][0].team_name
        team2 = current_activity.actions[-1][0].team_name
        # Special case for trades out of order
        while team2 == team1:
            i = 1
            team2 = current_activity.actions[i][0].team_name
            i += 1
        #initialize dictionary to store trade data, with date and teams.
        trades_dict = {'Date': str(date), 'Teams': [team1, team2], team1: [], team2: []}

        #store each player a team received in the trades dict
        for j in range(len(current_activity.actions)):
            current_player = current_activity.actions[j][2].name
            current_team = team1 if current_activity.actions[j][0].team_name == team2 else team2
            trades_dict[current_team].append(current_player)
        #append dicitonary to master list
        trades_data.append(trades_dict)
    #return master list
    return trades_data

That gives me a list of dictionaries, each one representing a trade. Here is an example of one:

{'Date': '2020-10-14', 'Teams': ['Commando Kilts', 'Greenbriar Cottonswabs'], 'Commando Kilts': ['Robert Woods', 'Nick Chubb'], 'Greenbriar Cottonswabs': ['Jonnu Smith', 'Keenan Allen']}

Since my analysis depends on finding how many starter points each player scored for a team, I don't have to be too careful tracking where players ended up throughout the course of the season, because all I'm grabbing is how many points that player scored for a particular owner, as a starter. I may have an issue when a player ends up back on a team who traded him away, however; I'm taking this one problem at a time. The nice thing about my list of dictionaries, is I can access each element specifically and use the gspread package to update a google sheet for the rest of the league to see.

Like I said, I'm sure there are much more elegant solutions, and I'm also sure there are problems with my approach I've yet to encounter, but it's done what I've needed it to so far.

[joshbis]

I don't have a good solution either! I did something similar in my league by setting it up as two tables: one with rows for each player's points per week; another identifying trades based on the recent activities. For anyone who was traded (identified via the activity feed), I could then track bench/starting points separately across the season for all weeks that a player was on those two teams.

But it did get messy (we had a lot of trades last year), especially for multi-player deals where one player in the trade gets dropped, picked up by someone else, or traded in another deal. I ended up just manually fixing the exceptions rather than coding out something elegant. I'd hoped that someone else had "solved" this -- but at least it gives you some things to watch out for.

Ultimately it was fun to see some of the disparities, but not super satisfying since points are less relevant than wins. Figuring out whether a deal won someone a game isn't always obvious from the points. To do that, you might have to calculate their whole season's record with vs. without the deal and that would get even more complicated.