class PlayerStats(object):
"""
Player represents a single player and all of his statistical categories.
Every player has 'playerid', 'name' and 'home' fields.
Additionally, depending upon which statistical categories that player
was involved in for the game, he'll have properties such as 'passing_tds',
'rushing_yds', 'defense_int' and 'kicking_fgm'.
In order to know whether a paricular player belongs to a statical category,
you may use the filtering methods of a player sequence or alternatively,
use the has_cat method with arguments like 'passing', 'rushing', 'kicking',
etc. (A player sequence in this case would be an instance of
GenPlayerStats.)
You may also inspect whether a player has a certain property by using
the special __dict__ attribute. For example::
if 'passing_yds' in player.__dict__:
# Do something with player.passing_yds
"""
def __init__(self, playerid, name, home):
"""
Create a new Player instance with the player id (from NFL.com's
GameCenter), the player's name (e.g., "T.Brady") and whether the
player is playing in a home game or not.
"""
self.playerid = playerid
self.name = name
self.home = home
self._stats = OrderedDict()
def has_cat(self, cat):
return self.__dict__.get(cat, False)
def __refresh_categories(self):
for cat in nflgame.statmap.categories:
for f in self.__dict__:
if f.startswith(cat):
self.__dict__[cat] = True
break
@property
def tds(self):
"""
Returns the total number of touchdowns credited to this player across
all statistical categories.
"""
n = 0
for f, v in self.__dict__.iteritems():
if f.endswith("tds"):
n += v
return n
@property
def stats(self):
"""
Returns a dict of all stats for the player.
"""
return self._stats
def formatted_stats(self):
"""
Returns a roughly-formatted string of all statistics for this player.
"""
s = []
for stat, val in self._stats.iteritems():
s.append("%s: %s" % (stat, val))
return ", ".join(s)
def _add_stats(self, stats):
for k, v in stats.iteritems():
self.__dict__[k] = self.__dict__.get(k, 0) + v
self._stats[k] = self.__dict__[k]
self.__refresh_categories()
def __str__(self):
"""
Simply returns the player's name, e.g., "T.Brady".
"""
return self.name
def __add__(self, other):
"""
Adds two players together. Only two player objects that correspond
to the same human (i.e., GameCenter identifier) can be added together.
If two different players are added together, an assertion will
be raised.
The effect of adding two player objects simply corresponds to the
sums of all statistical values.
Note that as soon as two players have been added, the 'home' property
becomes undefined.
"""
assert self.playerid == other.playerid
assert type(self) == type(other)
new_player = self.__class__(self.playerid, self.name, None)
new_player._add_stats(self._stats)
new_player._add_stats(other._stats)
return new_player
def __sub__(self, other):
assert self.playerid == other.playerid
assert type(self) == type(other)
new_player = GamePlayerStats(self.playerid, self.name, self.home)
new_player._add_stats(self._stats)
for bk, bv in other._stats.iteritems():
new_player._stats[bk] -= bv
if new_player._stats[bk] == 0:
del new_player._stats[bk]
else:
new_player.__dict__[bk] = new_player._stats[bk]
anydiffs = False
for k, v in new_player._stats.iteritems():
if v > 0:
anydiffs = True
break
if not anydiffs:
return None
return new_player
def __getattr__(self, name):
# If name has one of the categories as a prefix, then return
# a default value of zero
for cat in nflgame.statmap.categories:
if name.startswith(cat):
return 0
print name
raise AttributeError
class PlayerStats (object):
"""
Player represents a single player and all of his statistical categories.
Every player has 'playerid', 'name' and 'home' fields.
Additionally, depending upon which statistical categories that player
was involved in for the game, he'll have properties such as 'passing_tds',
'rushing_yds', 'defense_int' and 'kicking_fgm'.
In order to know whether a paricular player belongs to a statical category,
you may use the filtering methods of a player sequence or alternatively,
use the has_cat method with arguments like 'passing', 'rushing', 'kicking',
etc. (A player sequence in this case would be an instance of
GenPlayerStats.)
You may also inspect whether a player has a certain property by using
the special __dict__ attribute. For example::
if 'passing_yds' in player.__dict__:
# Do something with player.passing_yds
"""
def __init__(self, playerid, name, home):
"""
Create a new Player instance with the player id (from NFL.com's
GameCenter), the player's name (e.g., "T.Brady") and whether the
player is playing in a home game or not.
"""
self.playerid = playerid
self.name = name
self.home = home
self._stats = OrderedDict()
def has_cat(self, cat):
return self.__dict__.get(cat, False)
def __refresh_categories(self):
for cat in nflgame.statmap.categories:
for f in self.__dict__:
if f.startswith(cat):
self.__dict__[cat] = True
break
@property
def tds(self):
"""
Returns the total number of touchdowns credited to this player across
all statistical categories.
"""
n = 0
for f, v in self.__dict__.iteritems():
if f.endswith('tds'):
n += v
return n
@property
def stats(self):
"""
Returns a dict of all stats for the player.
"""
return self._stats
def formatted_stats(self):
"""
Returns a roughly-formatted string of all statistics for this player.
"""
s = []
for stat, val in self._stats.iteritems():
s.append('%s: %s' % (stat, val))
return ', '.join(s)
def _add_stats(self, stats):
for k, v in stats.iteritems():
self.__dict__[k] = self.__dict__.get(k, 0) + v
self._stats[k] = self.__dict__[k]
self.__refresh_categories()
def __str__(self):
"""
Simply returns the player's name, e.g., "T.Brady".
"""
return self.name
def __add__(self, other):
"""
Adds two players together. Only two player objects that correspond
to the same human (i.e., GameCenter identifier) can be added together.
If two different players are added together, an assertion will
be raised.
The effect of adding two player objects simply corresponds to the
sums of all statistical values.
Note that as soon as two players have been added, the 'home' property
becomes undefined.
"""
assert self.playerid == other.playerid
assert type(self) == type(other)
new_player = self.__class__(self.playerid, self.name, None)
new_player._add_stats(self._stats)
new_player._add_stats(other._stats)
return new_player
def __sub__(self, other):
assert self.playerid == other.playerid
assert type(self) == type(other)
new_player = GamePlayerStats(self.playerid, self.name, self.home)
new_player._add_stats(self._stats)
for bk, bv in other._stats.iteritems():
new_player._stats[bk] -= bv
if new_player._stats[bk] == 0:
del new_player._stats[bk]
else:
new_player.__dict__[bk] = new_player._stats[bk]
anydiffs = False
for k, v in new_player._stats.iteritems():
if v > 0:
anydiffs = True
break
if not anydiffs:
return None
return new_player
def __getattr__(self, name):
# If name has one of the categories as a prefix, then return
# a default value of zero
for cat in nflgame.statmap.categories:
if name.startswith(cat):
return 0
print name
raise AttributeError
class PlayerStats(object):
"""
Player represents a single player and all of his statistical categories.
Every player has 'playerid', 'name' and 'home' fields.
Additionally, depending upon which statistical categories that player
was involved in for the game, he'll have properties such as 'passing_tds',
'rushing_yds', 'defense_int' and 'kicking_fgm'.
In order to know whether a paricular player belongs to a statical category,
you may use the filtering methods of a player sequence or alternatively,
use the has_cat method with arguments like 'passing', 'rushing', 'kicking',
etc. (A player sequence in this case would be an instance of
GenPlayerStats.)
You may also inspect whether a player has a certain property by using
the special __dict__ attribute. For example::
if 'passing_yds' in player.__dict__:
# Do something with player.passing_yds
"""
def __init__(self, playerid, name, home, team):
"""
Create a new Player instance with the player id (from NFL.com's
GameCenter), the player's name (e.g., "T.Brady") and whether the
player is playing in a home game or not.
"""
self.playerid = playerid
self.name = name
self.home = home
self.team = team
self._stats = OrderedDict()
self.player = None
if self.playerid in nflgame.players:
self.player = nflgame.players[self.playerid]
def has_cat(self, cat):
for f in self._stats:
if f.startswith(cat):
return True
return False
@property
def guess_position(self):
"""
Guesses the position of this player based on the statistical
categories present in this object when player meta is not
present.
Note that if this resorts to a guess, then it will be more
effective on aggregate data rather than data from just a
single play. (e.g., if a QB runs the ball, and that's the
only data available, the position returned will be RB.)
When a position is guessed, only the following positions will
be returned: QB, RB, WR, DEF, K and P.
"""
# Look for the player meta first. Duh.
if self.player is not None:
return self.player.position
stats = [
(self.passing_att, 'QB'),
(self.rushing_att, 'RB'),
(self.receiving_tar, 'WR'),
(self.defense_tkl, 'DEF'),
(self.defense_ast, 'DEF'),
(self.kicking_tot, 'K'),
(self.kicking_fga, 'K'),
(self.punting_tot, 'P'),
]
return sorted(stats, reverse=True)[0][1]
@property
def tds(self):
"""
Returns the total number of touchdowns credited to this player across
all statistical categories.
"""
n = 0
for f, v in self.__dict__.iteritems():
if f.endswith('tds'):
n += v
return n
@property
def twopta(self):
"""
Returns the total number of two point conversion attempts for
the passing, rushing and receiving categories.
"""
return (self.passing_twopta + self.rushing_twopta +
self.receiving_twopta)
@property
def twoptm(self):
"""
Returns the total number of two point conversions for
the passing, rushing and receiving categories.
"""
return (self.passing_twoptm + self.rushing_twoptm +
self.receiving_twoptm)
@property
def twoptmissed(self):
"""
Returns the total number of two point conversion failures for
the passing, rushing and receiving categories.
"""
return (self.passing_twoptmissed + self.rushing_twoptmissed +
self.receiving_twoptmissed)
@property
def stats(self):
"""
Returns a dict of all stats for the player.
"""
return self._stats
def formatted_stats(self):
"""
Returns a roughly-formatted string of all statistics for this player.
"""
s = []
for stat, val in self._stats.iteritems():
s.append('%s: %s' % (stat, val))
return ', '.join(s)
def _add_stats(self, stats):
for k, v in stats.iteritems():
self.__dict__[k] = self.__dict__.get(k, 0) + v
self._stats[k] = self.__dict__[k]
def _overwrite_stats(self, stats):
for k, v in stats.iteritems():
self.__dict__[k] = v
self._stats[k] = self.__dict__[k]
def __str__(self):
"""
Simply returns the player's name, e.g., "T.Brady".
"""
return self.name
def __add__(self, other):
"""
Adds two players together. Only two player objects that correspond
to the same human (i.e., GameCenter identifier) can be added together.
If two different players are added together, an assertion will
be raised.
The effect of adding two player objects simply corresponds to the
sums of all statistical values.
Note that as soon as two players have been added, the 'home' property
becomes undefined if the two operands have different values of 'home'.
"""
assert self.playerid == other.playerid
assert type(self) == type(other)
if self.home != other.home:
home = None
else:
home = self.home
new_player = self.__class__(self.playerid, self.name, home, self.team)
new_player._add_stats(self._stats)
new_player._add_stats(other._stats)
return new_player
def __sub__(self, other):
assert self.playerid == other.playerid
assert type(self) == type(other)
new_player = GamePlayerStats(self.playerid, self.name, self.home,
self.team)
new_player._add_stats(self._stats)
for bk, bv in other._stats.iteritems():
if bk not in new_player._stats: # stat was taken away? ignore.
continue
new_player._stats[bk] -= bv
if new_player._stats[bk] == 0:
del new_player._stats[bk]
else:
new_player.__dict__[bk] = new_player._stats[bk]
anydiffs = False
for k, v in new_player._stats.iteritems():
if v > 0:
anydiffs = True
break
if not anydiffs:
return None
return new_player
def __getattr__(self, name):
# If name has one of the categories as a prefix, then return
# a default value of zero
for cat in nflgame.statmap.categories:
if name.startswith(cat):
return 0
raise AttributeError
class PlayerStats(object):
"""
Player represents a single player and all of his statistical categories.
Every player has 'playerid', 'name' and 'home' fields.
Additionally, depending upon which statistical categories that player
was involved in for the game, he'll have properties such as 'passing_tds',
'rushing_yds', 'defense_int' and 'kicking_fgm'.
In order to know whether a paricular player belongs to a statical category,
you may use the filtering methods of a player sequence or alternatively,
use the has_cat method with arguments like 'passing', 'rushing', 'kicking',
etc. (A player sequence in this case would be an instance of
GenPlayerStats.)
You may also inspect whether a player has a certain property by using
the special __dict__ attribute. For example::
if 'passing_yds' in player.__dict__:
# Do something with player.passing_yds
"""
def __init__(self, playerid, name, home, team):
"""
Create a new Player instance with the player id (from NFL.com's
GameCenter), the player's name (e.g., "T.Brady") and whether the
player is playing in a home game or not.
"""
self.playerid = playerid
self.name = name
self.home = home
self.team = team
self._stats = OrderedDict()
self.player = None
if self.playerid in nflgame.players:
self.player = nflgame.players[self.playerid]
def has_cat(self, cat):
for f in self._stats:
if f.startswith(cat):
return True
return False
@property
def guess_position(self):
"""
Guesses the position of this player based on the statistical
categories present in this object when player meta is not
present.
Note that if this resorts to a guess, then it will be more
effective on aggregate data rather than data from just a
single play. (e.g., if a QB runs the ball, and that's the
only data available, the position returned will be RB.)
When a position is guessed, only the following positions will
be returned: QB, RB, WR, DEF, K and P.
"""
# Look for the player meta first. Duh.
if self.player is not None:
return self.player.position
stats = [
(self.passing_att, "QB"),
(self.rushing_att, "RB"),
(self.receiving_tar, "WR"),
(self.defense_tkl, "DEF"),
(self.defense_ast, "DEF"),
(self.kicking_tot, "K"),
(self.kicking_fga, "K"),
(self.punting_tot, "P"),
]
return sorted(stats, reverse=True)[0][1]
@property
def tds(self):
"""
Returns the total number of touchdowns credited to this player across
all statistical categories.
"""
n = 0
for f, v in self.__dict__.iteritems():
if f.endswith("tds"):
n += v
return n
@property
def twopta(self):
"""
Returns the total number of two point conversion attempts for
the passing, rushing and receiving categories.
"""
return self.passing_twopta + self.rushing_twopta + self.receiving_twopta
@property
def twoptm(self):
"""
Returns the total number of two point conversions for
the passing, rushing and receiving categories.
"""
return self.passing_twoptm + self.rushing_twoptm + self.receiving_twoptm
@property
def twoptmissed(self):
"""
Returns the total number of two point conversion failures for
the passing, rushing and receiving categories.
"""
return self.passing_twoptmissed + self.rushing_twoptmissed + self.receiving_twoptmissed
@property
def stats(self):
"""
Returns a dict of all stats for the player.
"""
return self._stats
def formatted_stats(self):
"""
Returns a roughly-formatted string of all statistics for this player.
"""
s = []
for stat, val in self._stats.iteritems():
s.append("%s: %s" % (stat, val))
return ", ".join(s)
def _add_stats(self, stats):
for k, v in stats.iteritems():
self.__dict__[k] = self.__dict__.get(k, 0) + v
self._stats[k] = self.__dict__[k]
def _overwrite_stats(self, stats):
for k, v in stats.iteritems():
self.__dict__[k] = v
self._stats[k] = self.__dict__[k]
def __str__(self):
"""
Simply returns the player's name, e.g., "T.Brady".
"""
return self.name
def __add__(self, other):
"""
Adds two players together. Only two player objects that correspond
to the same human (i.e., GameCenter identifier) can be added together.
If two different players are added together, an assertion will
be raised.
The effect of adding two player objects simply corresponds to the
sums of all statistical values.
Note that as soon as two players have been added, the 'home' property
becomes undefined if the two operands have different values of 'home'.
"""
assert self.playerid == other.playerid
assert type(self) == type(other)
if self.home != other.home:
home = None
else:
home = self.home
new_player = self.__class__(self.playerid, self.name, home, self.team)
new_player._add_stats(self._stats)
new_player._add_stats(other._stats)
return new_player
def __sub__(self, other):
assert self.playerid == other.playerid
assert type(self) == type(other)
new_player = GamePlayerStats(self.playerid, self.name, self.home, self.team)
new_player._add_stats(self._stats)
for bk, bv in other._stats.iteritems():
if bk not in new_player._stats: # stat was taken away? ignore.
continue
new_player._stats[bk] -= bv
if new_player._stats[bk] == 0:
del new_player._stats[bk]
else:
new_player.__dict__[bk] = new_player._stats[bk]
anydiffs = False
for k, v in new_player._stats.iteritems():
if v > 0:
anydiffs = True
break
if not anydiffs:
return None
return new_player
def __getattr__(self, name):
# If name has one of the categories as a prefix, then return
# a default value of zero
for cat in nflgame.statmap.categories:
if name.startswith(cat):
return 0
raise AttributeError
def passer_rating(self):
"""
Calculate and return the passer rating using the NFL formula. Passer
rating is calculated using a player's passing attempts, completions,
yards, touchdowns, and interceptions. Passer rating in the NFL is on a
scale from 0 to 158.3.
"""
l = [((self.passing_cmp / self.passing_att) - 0.3) * 5]
l.append(((self.passing_yds / self.passing_att) - 3) * 0.25)
l.append((self.tds / self.passing_att) * 20)
l.append(2.375 - (self.passing_ints / self.passing_att * 25))
m = []
for a in l:
if a < 0:
a = 0
m.append(a)
elif a > 2.375:
a = 2.375
m.append(a)
else:
m.append(a)
rating = round((sum(m) / 6) * 100, 1)
return rating
