O model(modelo) é simples, é a fonte de dados definitiva para os seus dados. Ela contém os campos e comportamentos essenciais para os seus dados armazenados. Em geral, um model é uma tabela simples de um banco de dados.

O básico:

• O model é uma classe Python com subclasses django.db.models.Model.


• Os atributos do model representam um campo no banco de dados.


• Model metadata (não as informações dos fields) são informadas em uma classe chamada Meta.


• O metadata é usado pela pagina de administração do Django que vai dentro da classe chamada Admin.

Com tudo isso, Django lhe da uma API de acesso ao banco de dados gerada automaticamente, isso esta explicado em http://www.djangoproject.com/documentation/db-api/

Exemplo rápido.
Nesse exemplo definimos um model chamado Pessoa, com pri_nome e ult_nome:

class Pessoa(models.Model):
    pri_nome = models.CharField(max_length=30)
    ult_nome = models.CharField(max_length=30)

pri_nome e ult_nome são campos de um model. Cada campo é especificado por uma classe que denomina um atributo, e cada atributo é relacionado a uma coluna em um banco de dados.

O model de Pessoa criado a cima cria uma tabela no banco de dados como essa:
CREATE TABLE aplicacao_pessoa (
"id" serial NOT NULL PRIMARY KEY,
"pri_nome" varchar(30) NOT NULL,
"ult_nome" varchar(30) NOT NULL
);

Tabelas

O nome da tabela, aplicacao_pessoa, é derivado automaticamente do metadata do model, porém pode ser alterada.
Para poupar o seu tempo o Django deriva o nome da tabela do banco de dados a partir do nome da classe do model e da aplicação que a contem. O nome da tabela do banco de dados é construído pela junção do nome da aplicação - o nome usado em manage.py startapp - com o nome da classe do model, com um underscore entre eles.
Para alterar o nome da tabela no banco de dados use o parâmetro db_table na classe Meta, por exemplo:

class Pessoa(models.Model):
    pri_nome = models.CharField(max_length=30)
    ult_nome = models.CharField(max_length=30)


    class Meta:
        db_table = 'pessoa'

Chave Primária Automática

Por padrão o Django da ao model um campo como esse:

id = models.AutoField(primary_key=True)

Essa é uma chave primária que gera os códigos automaticamente (auto-increment).

Se você quiser especificar uma chave primária, especifique primary_key=True em um de seus campos. Se o Django ver que você especificou uma primary_key, ele não vai adicionar automaticamente uma coluna id.

Cada model requer exatamente um campo que contenha uma primary_key=True.

O CREATE TABLE nesse exemplo é formatado usando a sintaxe do PostgreSQL, mas devemos notar que o Django adapta o SQL ao banco de dados especificado no arquivo de configurações.

Campos (Fields)

É a parte mais importante de um model – e é a única parte requeria pelo model – é a lista dos campos definidos no banco de dados. Os atributos dos campos são especificados pelas classes.

Exemplo:

class Musico(models.Model):
    pri_nome = models.CharField(max_length=50)
    ult_nome = models.CharField(max_length=50)
    instrumento = models.CharField(max_length=100)


class Album(models.Model):
    artista = models.ForeignKey(Musico)
    nome = models.CharField(max_length=100)
    data_lancamento = models.DateField()
    num_estrelas = models.IntegerField()

Restrições nos nomes dos campos (fields)

Django tem duas restrições aos nomes dos campos no model:
1. O nome do campo não pode ser uma palavra reservada do Python, se não isso resultara em um erro de sintaxe do Python. Por exemplo:

class Exemplo(models.Model):
    pass = models.IntegerField() # 'pass' é uma palavra reservada!

2. O nome do campo não pode conter mais do que um underscore em uma linha, de acordo com a query do Django isso causa um trabalho repetitivo de sintaxe. Por Exemplo:

class Exemplo(models.Model):
    foo__bar = models.IntegerField() 
    # 'foo__bar' contem dois underscores!

Tipos de campos

Cada campo em seu model é uma instancia apropriada da classe Field. O Django usa a classe Field para determinar os tipos como:

O tipo de uma coluna no banco de dados (ex. INTEGER, VARCHAR).

O widget usado na interface de administração do Django (ex.<input type="text">,<select>).

É requerido o mínimo de validação, usado na adminstração do Django e manipuladores.

Lista completa dos tipos de campos:
* AutoField
* BooleanField
* CharField
* CommaSeparatedIntegerField
* DateField
* DateTimeField
* DecimalField
* EmailField
* FileField
* FilePathField
* FloatField
* ImageField
* IntegerField
* IPAddressField
* NullBooleanField
* PhoneNumberField
* PositiveIntegerField
* PositiveSmallIntegerField
* SlugField
* SmallIntegerField
* TextField
* TimeField
* URLField
* USStateField
* XMLField

Para ver detalhes sobre cada tipo leia a documentação oficial http://www.djangoproject.com/documentation/model-api/#field-types

Opções dos campos

Segue todos os argumentos avaliados para todos os tipos de campos, todos são opcionais.

null
Se True, o Django guarda um valor NULL no banco de dados. Padrão é False.

Mantenha os valores para string vazios e não como NULL. Use apenas null=True para campos não string como integers, booleans, e dates, Para todos os outros use blank=True se você permitir campos vazios no formulário, o parâmetro NULL afeta apenas o banco de dados.

blank
Se True, o campo poderá ficar vazio. Padrão é False.
Se o campo estiver como blank=False o campo será requerido.

# choices
# core
# db_column
# db_index
# db_tablespace
# default
# editable
# help_text
# primary_key
# radio_admin
# unique
# unique_for_date
# unique_for_month
# unique_for_year
# validator_list

Para ver o que cada opção dessas faz acesse a documentação oficial http://www.djangoproject.com/documentation/model-api/#field-options

Descrição do nome de campos

Para cada tipo, exceto por ForeignKey, ManyToManyField e OneToOneField, se tem um primeiro argumento opcional - a descrição do nome. Se a descrição não for alterada o Django atribui automaticamente usando o nome do campo, convertendo os espaços em underscores.

Nesse exemplo, a descrição do campo é "Primeiro nome da pessoa":

pri_nome = models.CharField("Primeiro nome da pessoa", max_length=30)

E nesse exemplo a descrição do campo é "pri_nome":

pri_nome = models.CharField(max_length=30)

ForeignKey, ManyToManyField e OneToOneField requerem que o primeiro argumento seja uma classe de um model, então é usado o argumento verbose_name:

poll = models.ForeignKey(Poll, verbose_name="the related poll")
sites = models.ManyToManyField(Site, verbose_name="list of sites")
place = models.OneToOneField(Place, verbose_name="related place")

Convém não deixar a primeira letra em maiúscula em verbose_name. O Django converte automaticamente a primeira letra para maiúscula.
Para saber mais sobre os relacionamentos consulte a documentação oficial http://www.djangoproject.com/documentation/model-api/#relationships

Admin options

Se você quiser que seu model fique visível ao site de administração do Django, adicione a classe Admin assim:

class Pessoa(models.Model):
    pri_name = models.CharField(max_length=30)
    ult_name = models.CharField(max_length=30)


    class Admin:
        # Admin options aqui
        pass

A classe Admin diz para o Django mostrar o model no site de administração.
Para ver mais opções da classe Admin veja a documentação oficial http://www.djangoproject.com/documentation/model-api/#admin-options

Isso foi um resumo bem curto da documentação oficial, abordei apenas aquilo que acho interessante para se iniciar o aprendizado em models e todos os seus conceitos.
Espero que gostem, aceito críticas e sugestões para melhorar o artigo.
Ref. Model-API

Abraços