On Jan 3, 2:36 pm, Tijmen <tijmen.vandenbr...@gmail.com> wrote:
> Hi there,
>
> 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
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
--
You received this message because you are subscribed to the Google Groups
"Django users" group.
To post to this group, send email to django-us...@googlegroups.com.
To unsubscribe from this group, send email to
django-users+unsubscr...@googlegroups.com.
For more options, visit this group at
http://groups.google.com/group/django-users?hl=en.
