Baseball statistics
Tijmen
First of all let me say I'm just starting here but need some help with
a rather basic question.
I want to make an app that holds baseball statistics for players of
each game and over several seasons. Now I'm new to this db
relationship thing and would like to hear your opinion.
My models.py currently looks like this:
<code>
from django.db import models
# Create your models here.
class Player(models.Model):
GENDER_CHOICES = (
('M', 'Male'),
('F', 'Female'),
)
BATS_CHOICES = (
('R', 'Right'),
('L', 'Left'),
('B', 'Both'),
)
THROWS_CHOICES = (
('R', 'Right'),
('L', 'Left'),
('B', 'Both'),
)
first_name = models.CharField(max_length=50)
last_name = models.CharField(max_length=50)
gender = models.CharField(max_length=1, choices=GENDER_CHOICES)
bats = models.CharField(max_length=1, choices=BATS_CHOICES)
throws = models.CharField(max_length=1, choices=THROWS_CHOICES)
birthdate = models.DateTimeField('birth date')
awards = models.CharField(max_length=200)
height = models.IntegerField()
weight = models.IntegerField()
email = models.CharField(max_length=100)
tel = models.CharField(max_length=50)
def __unicode__(self):
#return self.first_name, self.last_name, self.gender
return self.first_name + " " + self.last_name
class Game(models.Model):
#players = models.ManyToManyField(Player) #Player
team = models.CharField(max_length=200) #Team for
which the player plays
league = models.CharField(max_length=200) #League
opponent = models.CharField(max_length=200) #The opponent
date = models.DateTimeField('date') #Date
def __unicode__(self):
return self.team + " vs " + self.opponent
class Season(models.Model):
year = models.DateTimeField('year')
def __unicode__(self):
return self.year
class Statistic(models.Model):
players = models.ManyToManyField(Player)
games = models.ManyToManyField(Game)
g = models.IntegerField() #Games played
or pitched
pa = models.IntegerField() #Plate
appearances estimated using AB + BB + HBP + SF + SH missing catcher
interferences
ab = models.IntegerField() #At bats
r = models.IntegerField() #Runs scored/
allowed
h = models.IntegerField() #Hits/hits
allowed
doubles = models.IntegerField() #Doubles hit/
allowed
triples = models.IntegerField() #Triples hit/
allowed
hr = models.IntegerField() #Home Runs hit/
allowed
rbi = models.IntegerField() #Runs Batted
In
sb = models.IntegerField() #Stolen Bases
cs = models.IntegerField() #Caught
Stealing
bb = models.IntegerField() #Bases on
Balls/Walks
so = models.IntegerField() #Strikeouts
ba = models.IntegerField() #Hits/At bats
obp = models.IntegerField() #On Base
Percentage (H + BB + HBP)/(AB + BB + HBP + SF)
slg = models.IntegerField() #Slugging,
Total Bases/At Bats (1B + 2 * 2B + 3 * 3B + 4 * HR)/AB
ops = models.IntegerField() #On base +
Slugging Percentages
opsplus = models.IntegerField() #100*[OBP/lg
OBP + SLG/lg SLG -1]
tb = models.IntegerField() #Total Bases
gdp = models.IntegerField() #Double Plays
Grounded Into
hbp = models.IntegerField() #Times Hit by
a Pitch
sh = models.IntegerField() #Sacrifice
Hits/Bunts
sf = models.IntegerField() #Sacrifice
Flies
ibb = models.IntegerField() #Intentional
Bases on Balls
pos = models.CharField(max_length=15) #Positions
def __unicode__(self):
return "Stats"
</code>
As you can see I have 4 classes defined:
- player
- game
- statistic
- season
A game is played with several players, each player has statistics for
this game and a game is part of a season. Now I'm a bit lost in what
kind of relationship I should use. models.ManyToManyField or
models.ForeignKey... And where I should put the statement.
Any help would be greatly appreciated.
Thanks
- Tijmen
greatlemer
Hi,
First of all, I just wanted to confirm that a statistic represents a
player's performance for a single game (it sounded like that from your
question at the end but was unclear thanks to the "g" field on the
Statistic model), I'll assume that it does.
In this case you should have the following relationships:
Since a game occurs in a single season, you want to have a ForeignKey
in the Game model that represents the season that game occurred in.
If Statistic does represent a stat for a specific player in a specific
game then it should contain two foreign keys, one to Player and one to
Game.
Finally you can add a ManyToMany field to either Player or Game (it
doesn't matter which one it goes on, but should only be on one) and
you can specify that Statistic is the "through" table [1]. You could
do that like this:
players = models.ManyToManyField(Player, through='Statistic',
related_name='games') # This would go in Game
games = models.ManyToManyField(Game, through='Statistic',
related_name='players') # This would go in Player
The related_name argument will be the name given to the relationship
on the other model, so with either of these you would have access to
games on the Player model and players on the Game model.
Hope this helps.
[1] http://docs.djangoproject.com/en/dev/topics/db/models/#intermediary-manytomany
--
G
Tijmen
field is redundant.
Thanks again!
> [1]http://docs.djangoproject.com/en/dev/topics/db/models/#intermediary-m...
>
> --
>
> G